3255 lines
100 KiB
C++
3255 lines
100 KiB
C++
/*++
|
|
|
|
Copyright (c) Microsoft Corporation. All rights reserved.
|
|
|
|
Module Name:
|
|
|
|
xnamathmatrix.inl
|
|
|
|
Abstract:
|
|
|
|
XNA math library for Windows and Xbox 360: Matrix functions
|
|
--*/
|
|
|
|
#if defined(_MSC_VER) && (_MSC_VER > 1000)
|
|
#pragma once
|
|
#endif
|
|
|
|
#ifndef __XNAMATHMATRIX_INL__
|
|
#define __XNAMATHMATRIX_INL__
|
|
|
|
/****************************************************************************
|
|
*
|
|
* Matrix
|
|
*
|
|
****************************************************************************/
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Comparison operations
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
// Return TRUE if any entry in the matrix is NaN
|
|
XMFINLINE BOOL XMMatrixIsNaN
|
|
(
|
|
CXMMATRIX M
|
|
)
|
|
{
|
|
#if defined(_XM_NO_INTRINSICS_)
|
|
UINT i, uTest;
|
|
const UINT *pWork;
|
|
|
|
i = 16;
|
|
pWork = (const UINT *)(&M.m[0][0]);
|
|
do {
|
|
// Fetch value into integer unit
|
|
uTest = pWork[0];
|
|
// Remove sign
|
|
uTest &= 0x7FFFFFFFU;
|
|
// NaN is 0x7F800001 through 0x7FFFFFFF inclusive
|
|
uTest -= 0x7F800001U;
|
|
if (uTest<0x007FFFFFU) {
|
|
break; // NaN found
|
|
}
|
|
++pWork; // Next entry
|
|
} while (--i);
|
|
return (i!=0); // i == 0 if nothing matched
|
|
#elif defined(_XM_SSE_INTRINSICS_)
|
|
// Load in registers
|
|
XMVECTOR vX = M.r[0];
|
|
XMVECTOR vY = M.r[1];
|
|
XMVECTOR vZ = M.r[2];
|
|
XMVECTOR vW = M.r[3];
|
|
// Test themselves to check for NaN
|
|
vX = _mm_cmpneq_ps(vX,vX);
|
|
vY = _mm_cmpneq_ps(vY,vY);
|
|
vZ = _mm_cmpneq_ps(vZ,vZ);
|
|
vW = _mm_cmpneq_ps(vW,vW);
|
|
// Or all the results
|
|
vX = _mm_or_ps(vX,vZ);
|
|
vY = _mm_or_ps(vY,vW);
|
|
vX = _mm_or_ps(vX,vY);
|
|
// If any tested true, return true
|
|
return (_mm_movemask_ps(vX)!=0);
|
|
#else
|
|
#endif
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
// Return TRUE if any entry in the matrix is +/-INF
|
|
XMFINLINE BOOL XMMatrixIsInfinite
|
|
(
|
|
CXMMATRIX M
|
|
)
|
|
{
|
|
#if defined(_XM_NO_INTRINSICS_)
|
|
UINT i, uTest;
|
|
const UINT *pWork;
|
|
|
|
i = 16;
|
|
pWork = (const UINT *)(&M.m[0][0]);
|
|
do {
|
|
// Fetch value into integer unit
|
|
uTest = pWork[0];
|
|
// Remove sign
|
|
uTest &= 0x7FFFFFFFU;
|
|
// INF is 0x7F800000
|
|
if (uTest==0x7F800000U) {
|
|
break; // INF found
|
|
}
|
|
++pWork; // Next entry
|
|
} while (--i);
|
|
return (i!=0); // i == 0 if nothing matched
|
|
#elif defined(_XM_SSE_INTRINSICS_)
|
|
// Mask off the sign bits
|
|
XMVECTOR vTemp1 = _mm_and_ps(M.r[0],g_XMAbsMask);
|
|
XMVECTOR vTemp2 = _mm_and_ps(M.r[1],g_XMAbsMask);
|
|
XMVECTOR vTemp3 = _mm_and_ps(M.r[2],g_XMAbsMask);
|
|
XMVECTOR vTemp4 = _mm_and_ps(M.r[3],g_XMAbsMask);
|
|
// Compare to infinity
|
|
vTemp1 = _mm_cmpeq_ps(vTemp1,g_XMInfinity);
|
|
vTemp2 = _mm_cmpeq_ps(vTemp2,g_XMInfinity);
|
|
vTemp3 = _mm_cmpeq_ps(vTemp3,g_XMInfinity);
|
|
vTemp4 = _mm_cmpeq_ps(vTemp4,g_XMInfinity);
|
|
// Or the answers together
|
|
vTemp1 = _mm_or_ps(vTemp1,vTemp2);
|
|
vTemp3 = _mm_or_ps(vTemp3,vTemp4);
|
|
vTemp1 = _mm_or_ps(vTemp1,vTemp3);
|
|
// If any are infinity, the signs are true.
|
|
return (_mm_movemask_ps(vTemp1)!=0);
|
|
#else // _XM_VMX128_INTRINSICS_
|
|
#endif // _XM_VMX128_INTRINSICS_
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
// Return TRUE if the XMMatrix is equal to identity
|
|
XMFINLINE BOOL XMMatrixIsIdentity
|
|
(
|
|
CXMMATRIX M
|
|
)
|
|
{
|
|
#if defined(_XM_NO_INTRINSICS_)
|
|
unsigned int uOne, uZero;
|
|
const unsigned int *pWork;
|
|
|
|
// Use the integer pipeline to reduce branching to a minimum
|
|
pWork = (const unsigned int*)(&M.m[0][0]);
|
|
// Convert 1.0f to zero and or them together
|
|
uOne = pWork[0]^0x3F800000U;
|
|
// Or all the 0.0f entries together
|
|
uZero = pWork[1];
|
|
uZero |= pWork[2];
|
|
uZero |= pWork[3];
|
|
// 2nd row
|
|
uZero |= pWork[4];
|
|
uOne |= pWork[5]^0x3F800000U;
|
|
uZero |= pWork[6];
|
|
uZero |= pWork[7];
|
|
// 3rd row
|
|
uZero |= pWork[8];
|
|
uZero |= pWork[9];
|
|
uOne |= pWork[10]^0x3F800000U;
|
|
uZero |= pWork[11];
|
|
// 4th row
|
|
uZero |= pWork[12];
|
|
uZero |= pWork[13];
|
|
uZero |= pWork[14];
|
|
uOne |= pWork[15]^0x3F800000U;
|
|
// If all zero entries are zero, the uZero==0
|
|
uZero &= 0x7FFFFFFF; // Allow -0.0f
|
|
// If all 1.0f entries are 1.0f, then uOne==0
|
|
uOne |= uZero;
|
|
return (uOne==0);
|
|
#elif defined(_XM_SSE_INTRINSICS_)
|
|
XMVECTOR vTemp1 = _mm_cmpeq_ps(M.r[0],g_XMIdentityR0);
|
|
XMVECTOR vTemp2 = _mm_cmpeq_ps(M.r[1],g_XMIdentityR1);
|
|
XMVECTOR vTemp3 = _mm_cmpeq_ps(M.r[2],g_XMIdentityR2);
|
|
XMVECTOR vTemp4 = _mm_cmpeq_ps(M.r[3],g_XMIdentityR3);
|
|
vTemp1 = _mm_and_ps(vTemp1,vTemp2);
|
|
vTemp3 = _mm_and_ps(vTemp3,vTemp4);
|
|
vTemp1 = _mm_and_ps(vTemp1,vTemp3);
|
|
return (_mm_movemask_ps(vTemp1)==0x0f);
|
|
#else // _XM_VMX128_INTRINSICS_
|
|
#endif // _XM_VMX128_INTRINSICS_
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Computation operations
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Perform a 4x4 matrix multiply by a 4x4 matrix
|
|
XMFINLINE XMMATRIX XMMatrixMultiply
|
|
(
|
|
CXMMATRIX M1,
|
|
CXMMATRIX M2
|
|
)
|
|
{
|
|
#if defined(_XM_NO_INTRINSICS_)
|
|
XMMATRIX mResult;
|
|
// Cache the invariants in registers
|
|
float x = M1.m[0][0];
|
|
float y = M1.m[0][1];
|
|
float z = M1.m[0][2];
|
|
float w = M1.m[0][3];
|
|
// Perform the operation on the first row
|
|
mResult.m[0][0] = (M2.m[0][0]*x)+(M2.m[1][0]*y)+(M2.m[2][0]*z)+(M2.m[3][0]*w);
|
|
mResult.m[0][1] = (M2.m[0][1]*x)+(M2.m[1][1]*y)+(M2.m[2][1]*z)+(M2.m[3][1]*w);
|
|
mResult.m[0][2] = (M2.m[0][2]*x)+(M2.m[1][2]*y)+(M2.m[2][2]*z)+(M2.m[3][2]*w);
|
|
mResult.m[0][3] = (M2.m[0][3]*x)+(M2.m[1][3]*y)+(M2.m[2][3]*z)+(M2.m[3][3]*w);
|
|
// Repeat for all the other rows
|
|
x = M1.m[1][0];
|
|
y = M1.m[1][1];
|
|
z = M1.m[1][2];
|
|
w = M1.m[1][3];
|
|
mResult.m[1][0] = (M2.m[0][0]*x)+(M2.m[1][0]*y)+(M2.m[2][0]*z)+(M2.m[3][0]*w);
|
|
mResult.m[1][1] = (M2.m[0][1]*x)+(M2.m[1][1]*y)+(M2.m[2][1]*z)+(M2.m[3][1]*w);
|
|
mResult.m[1][2] = (M2.m[0][2]*x)+(M2.m[1][2]*y)+(M2.m[2][2]*z)+(M2.m[3][2]*w);
|
|
mResult.m[1][3] = (M2.m[0][3]*x)+(M2.m[1][3]*y)+(M2.m[2][3]*z)+(M2.m[3][3]*w);
|
|
x = M1.m[2][0];
|
|
y = M1.m[2][1];
|
|
z = M1.m[2][2];
|
|
w = M1.m[2][3];
|
|
mResult.m[2][0] = (M2.m[0][0]*x)+(M2.m[1][0]*y)+(M2.m[2][0]*z)+(M2.m[3][0]*w);
|
|
mResult.m[2][1] = (M2.m[0][1]*x)+(M2.m[1][1]*y)+(M2.m[2][1]*z)+(M2.m[3][1]*w);
|
|
mResult.m[2][2] = (M2.m[0][2]*x)+(M2.m[1][2]*y)+(M2.m[2][2]*z)+(M2.m[3][2]*w);
|
|
mResult.m[2][3] = (M2.m[0][3]*x)+(M2.m[1][3]*y)+(M2.m[2][3]*z)+(M2.m[3][3]*w);
|
|
x = M1.m[3][0];
|
|
y = M1.m[3][1];
|
|
z = M1.m[3][2];
|
|
w = M1.m[3][3];
|
|
mResult.m[3][0] = (M2.m[0][0]*x)+(M2.m[1][0]*y)+(M2.m[2][0]*z)+(M2.m[3][0]*w);
|
|
mResult.m[3][1] = (M2.m[0][1]*x)+(M2.m[1][1]*y)+(M2.m[2][1]*z)+(M2.m[3][1]*w);
|
|
mResult.m[3][2] = (M2.m[0][2]*x)+(M2.m[1][2]*y)+(M2.m[2][2]*z)+(M2.m[3][2]*w);
|
|
mResult.m[3][3] = (M2.m[0][3]*x)+(M2.m[1][3]*y)+(M2.m[2][3]*z)+(M2.m[3][3]*w);
|
|
return mResult;
|
|
#elif defined(_XM_SSE_INTRINSICS_)
|
|
XMMATRIX mResult;
|
|
// Use vW to hold the original row
|
|
XMVECTOR vW = M1.r[0];
|
|
// Splat the component X,Y,Z then W
|
|
XMVECTOR vX = _mm_shuffle_ps(vW,vW,_MM_SHUFFLE(0,0,0,0));
|
|
XMVECTOR vY = _mm_shuffle_ps(vW,vW,_MM_SHUFFLE(1,1,1,1));
|
|
XMVECTOR vZ = _mm_shuffle_ps(vW,vW,_MM_SHUFFLE(2,2,2,2));
|
|
vW = _mm_shuffle_ps(vW,vW,_MM_SHUFFLE(3,3,3,3));
|
|
// Perform the opertion on the first row
|
|
vX = _mm_mul_ps(vX,M2.r[0]);
|
|
vY = _mm_mul_ps(vY,M2.r[1]);
|
|
vZ = _mm_mul_ps(vZ,M2.r[2]);
|
|
vW = _mm_mul_ps(vW,M2.r[3]);
|
|
// Perform a binary add to reduce cumulative errors
|
|
vX = _mm_add_ps(vX,vZ);
|
|
vY = _mm_add_ps(vY,vW);
|
|
vX = _mm_add_ps(vX,vY);
|
|
mResult.r[0] = vX;
|
|
// Repeat for the other 3 rows
|
|
vW = M1.r[1];
|
|
vX = _mm_shuffle_ps(vW,vW,_MM_SHUFFLE(0,0,0,0));
|
|
vY = _mm_shuffle_ps(vW,vW,_MM_SHUFFLE(1,1,1,1));
|
|
vZ = _mm_shuffle_ps(vW,vW,_MM_SHUFFLE(2,2,2,2));
|
|
vW = _mm_shuffle_ps(vW,vW,_MM_SHUFFLE(3,3,3,3));
|
|
vX = _mm_mul_ps(vX,M2.r[0]);
|
|
vY = _mm_mul_ps(vY,M2.r[1]);
|
|
vZ = _mm_mul_ps(vZ,M2.r[2]);
|
|
vW = _mm_mul_ps(vW,M2.r[3]);
|
|
vX = _mm_add_ps(vX,vZ);
|
|
vY = _mm_add_ps(vY,vW);
|
|
vX = _mm_add_ps(vX,vY);
|
|
mResult.r[1] = vX;
|
|
vW = M1.r[2];
|
|
vX = _mm_shuffle_ps(vW,vW,_MM_SHUFFLE(0,0,0,0));
|
|
vY = _mm_shuffle_ps(vW,vW,_MM_SHUFFLE(1,1,1,1));
|
|
vZ = _mm_shuffle_ps(vW,vW,_MM_SHUFFLE(2,2,2,2));
|
|
vW = _mm_shuffle_ps(vW,vW,_MM_SHUFFLE(3,3,3,3));
|
|
vX = _mm_mul_ps(vX,M2.r[0]);
|
|
vY = _mm_mul_ps(vY,M2.r[1]);
|
|
vZ = _mm_mul_ps(vZ,M2.r[2]);
|
|
vW = _mm_mul_ps(vW,M2.r[3]);
|
|
vX = _mm_add_ps(vX,vZ);
|
|
vY = _mm_add_ps(vY,vW);
|
|
vX = _mm_add_ps(vX,vY);
|
|
mResult.r[2] = vX;
|
|
vW = M1.r[3];
|
|
vX = _mm_shuffle_ps(vW,vW,_MM_SHUFFLE(0,0,0,0));
|
|
vY = _mm_shuffle_ps(vW,vW,_MM_SHUFFLE(1,1,1,1));
|
|
vZ = _mm_shuffle_ps(vW,vW,_MM_SHUFFLE(2,2,2,2));
|
|
vW = _mm_shuffle_ps(vW,vW,_MM_SHUFFLE(3,3,3,3));
|
|
vX = _mm_mul_ps(vX,M2.r[0]);
|
|
vY = _mm_mul_ps(vY,M2.r[1]);
|
|
vZ = _mm_mul_ps(vZ,M2.r[2]);
|
|
vW = _mm_mul_ps(vW,M2.r[3]);
|
|
vX = _mm_add_ps(vX,vZ);
|
|
vY = _mm_add_ps(vY,vW);
|
|
vX = _mm_add_ps(vX,vY);
|
|
mResult.r[3] = vX;
|
|
return mResult;
|
|
#else // _XM_VMX128_INTRINSICS_
|
|
#endif // _XM_VMX128_INTRINSICS_
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
XMFINLINE XMMATRIX XMMatrixMultiplyTranspose
|
|
(
|
|
CXMMATRIX M1,
|
|
CXMMATRIX M2
|
|
)
|
|
{
|
|
#if defined(_XM_NO_INTRINSICS_)
|
|
XMMATRIX mResult;
|
|
// Cache the invariants in registers
|
|
float x = M2.m[0][0];
|
|
float y = M2.m[1][0];
|
|
float z = M2.m[2][0];
|
|
float w = M2.m[3][0];
|
|
// Perform the operation on the first row
|
|
mResult.m[0][0] = (M1.m[0][0]*x)+(M1.m[0][1]*y)+(M1.m[0][2]*z)+(M1.m[0][3]*w);
|
|
mResult.m[0][1] = (M1.m[1][0]*x)+(M1.m[1][1]*y)+(M1.m[1][2]*z)+(M1.m[1][3]*w);
|
|
mResult.m[0][2] = (M1.m[2][0]*x)+(M1.m[2][1]*y)+(M1.m[2][2]*z)+(M1.m[2][3]*w);
|
|
mResult.m[0][3] = (M1.m[3][0]*x)+(M1.m[3][1]*y)+(M1.m[3][2]*z)+(M1.m[3][3]*w);
|
|
// Repeat for all the other rows
|
|
x = M2.m[0][1];
|
|
y = M2.m[1][1];
|
|
z = M2.m[2][1];
|
|
w = M2.m[3][1];
|
|
mResult.m[1][0] = (M1.m[0][0]*x)+(M1.m[0][1]*y)+(M1.m[0][2]*z)+(M1.m[0][3]*w);
|
|
mResult.m[1][1] = (M1.m[1][0]*x)+(M1.m[1][1]*y)+(M1.m[1][2]*z)+(M1.m[1][3]*w);
|
|
mResult.m[1][2] = (M1.m[2][0]*x)+(M1.m[2][1]*y)+(M1.m[2][2]*z)+(M1.m[2][3]*w);
|
|
mResult.m[1][3] = (M1.m[3][0]*x)+(M1.m[3][1]*y)+(M1.m[3][2]*z)+(M1.m[3][3]*w);
|
|
x = M2.m[0][2];
|
|
y = M2.m[1][2];
|
|
z = M2.m[2][2];
|
|
w = M2.m[3][2];
|
|
mResult.m[2][0] = (M1.m[0][0]*x)+(M1.m[0][1]*y)+(M1.m[0][2]*z)+(M1.m[0][3]*w);
|
|
mResult.m[2][1] = (M1.m[1][0]*x)+(M1.m[1][1]*y)+(M1.m[1][2]*z)+(M1.m[1][3]*w);
|
|
mResult.m[2][2] = (M1.m[2][0]*x)+(M1.m[2][1]*y)+(M1.m[2][2]*z)+(M1.m[2][3]*w);
|
|
mResult.m[2][3] = (M1.m[3][0]*x)+(M1.m[3][1]*y)+(M1.m[3][2]*z)+(M1.m[3][3]*w);
|
|
x = M2.m[0][3];
|
|
y = M2.m[1][3];
|
|
z = M2.m[2][3];
|
|
w = M2.m[3][3];
|
|
mResult.m[3][0] = (M1.m[0][0]*x)+(M1.m[0][1]*y)+(M1.m[0][2]*z)+(M1.m[0][3]*w);
|
|
mResult.m[3][1] = (M1.m[1][0]*x)+(M1.m[1][1]*y)+(M1.m[1][2]*z)+(M1.m[1][3]*w);
|
|
mResult.m[3][2] = (M1.m[2][0]*x)+(M1.m[2][1]*y)+(M1.m[2][2]*z)+(M1.m[2][3]*w);
|
|
mResult.m[3][3] = (M1.m[3][0]*x)+(M1.m[3][1]*y)+(M1.m[3][2]*z)+(M1.m[3][3]*w);
|
|
return mResult;
|
|
#elif defined(_XM_SSE_INTRINSICS_)
|
|
XMMATRIX Product;
|
|
XMMATRIX Result;
|
|
Product = XMMatrixMultiply(M1, M2);
|
|
Result = XMMatrixTranspose(Product);
|
|
return Result;
|
|
#else // _XM_VMX128_INTRINSICS_
|
|
#endif // _XM_VMX128_INTRINSICS_
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
XMFINLINE XMMATRIX XMMatrixTranspose
|
|
(
|
|
CXMMATRIX M
|
|
)
|
|
{
|
|
#if defined(_XM_NO_INTRINSICS_)
|
|
|
|
XMMATRIX P;
|
|
XMMATRIX MT;
|
|
|
|
// Original matrix:
|
|
//
|
|
// m00m01m02m03
|
|
// m10m11m12m13
|
|
// m20m21m22m23
|
|
// m30m31m32m33
|
|
|
|
P.r[0] = XMVectorMergeXY(M.r[0], M.r[2]); // m00m20m01m21
|
|
P.r[1] = XMVectorMergeXY(M.r[1], M.r[3]); // m10m30m11m31
|
|
P.r[2] = XMVectorMergeZW(M.r[0], M.r[2]); // m02m22m03m23
|
|
P.r[3] = XMVectorMergeZW(M.r[1], M.r[3]); // m12m32m13m33
|
|
|
|
MT.r[0] = XMVectorMergeXY(P.r[0], P.r[1]); // m00m10m20m30
|
|
MT.r[1] = XMVectorMergeZW(P.r[0], P.r[1]); // m01m11m21m31
|
|
MT.r[2] = XMVectorMergeXY(P.r[2], P.r[3]); // m02m12m22m32
|
|
MT.r[3] = XMVectorMergeZW(P.r[2], P.r[3]); // m03m13m23m33
|
|
|
|
return MT;
|
|
|
|
#elif defined(_XM_SSE_INTRINSICS_)
|
|
// x.x,x.y,y.x,y.y
|
|
XMVECTOR vTemp1 = _mm_shuffle_ps(M.r[0],M.r[1],_MM_SHUFFLE(1,0,1,0));
|
|
// x.z,x.w,y.z,y.w
|
|
XMVECTOR vTemp3 = _mm_shuffle_ps(M.r[0],M.r[1],_MM_SHUFFLE(3,2,3,2));
|
|
// z.x,z.y,w.x,w.y
|
|
XMVECTOR vTemp2 = _mm_shuffle_ps(M.r[2],M.r[3],_MM_SHUFFLE(1,0,1,0));
|
|
// z.z,z.w,w.z,w.w
|
|
XMVECTOR vTemp4 = _mm_shuffle_ps(M.r[2],M.r[3],_MM_SHUFFLE(3,2,3,2));
|
|
XMMATRIX mResult;
|
|
|
|
// x.x,y.x,z.x,w.x
|
|
mResult.r[0] = _mm_shuffle_ps(vTemp1, vTemp2,_MM_SHUFFLE(2,0,2,0));
|
|
// x.y,y.y,z.y,w.y
|
|
mResult.r[1] = _mm_shuffle_ps(vTemp1, vTemp2,_MM_SHUFFLE(3,1,3,1));
|
|
// x.z,y.z,z.z,w.z
|
|
mResult.r[2] = _mm_shuffle_ps(vTemp3, vTemp4,_MM_SHUFFLE(2,0,2,0));
|
|
// x.w,y.w,z.w,w.w
|
|
mResult.r[3] = _mm_shuffle_ps(vTemp3, vTemp4,_MM_SHUFFLE(3,1,3,1));
|
|
return mResult;
|
|
#else // _XM_VMX128_INTRINSICS_
|
|
#endif // _XM_VMX128_INTRINSICS_
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Return the inverse and the determinant of a 4x4 matrix
|
|
XMINLINE XMMATRIX XMMatrixInverse
|
|
(
|
|
XMVECTOR* pDeterminant,
|
|
CXMMATRIX M
|
|
)
|
|
{
|
|
#if defined(_XM_NO_INTRINSICS_)
|
|
|
|
XMMATRIX R;
|
|
XMMATRIX MT;
|
|
XMVECTOR D0, D1, D2;
|
|
XMVECTOR C0, C1, C2, C3, C4, C5, C6, C7;
|
|
XMVECTOR V0[4], V1[4];
|
|
XMVECTOR Determinant;
|
|
XMVECTOR Reciprocal;
|
|
XMMATRIX Result;
|
|
static CONST XMVECTORU32 SwizzleXXYY = {XM_PERMUTE_0X, XM_PERMUTE_0X, XM_PERMUTE_0Y, XM_PERMUTE_0Y};
|
|
static CONST XMVECTORU32 SwizzleZWZW = {XM_PERMUTE_0Z, XM_PERMUTE_0W, XM_PERMUTE_0Z, XM_PERMUTE_0W};
|
|
static CONST XMVECTORU32 SwizzleYZXY = {XM_PERMUTE_0Y, XM_PERMUTE_0Z, XM_PERMUTE_0X, XM_PERMUTE_0Y};
|
|
static CONST XMVECTORU32 SwizzleZWYZ = {XM_PERMUTE_0Z, XM_PERMUTE_0W, XM_PERMUTE_0Y, XM_PERMUTE_0Z};
|
|
static CONST XMVECTORU32 SwizzleWXWX = {XM_PERMUTE_0W, XM_PERMUTE_0X, XM_PERMUTE_0W, XM_PERMUTE_0X};
|
|
static CONST XMVECTORU32 SwizzleZXYX = {XM_PERMUTE_0Z, XM_PERMUTE_0X, XM_PERMUTE_0Y, XM_PERMUTE_0X};
|
|
static CONST XMVECTORU32 SwizzleYWXZ = {XM_PERMUTE_0Y, XM_PERMUTE_0W, XM_PERMUTE_0X, XM_PERMUTE_0Z};
|
|
static CONST XMVECTORU32 SwizzleWZWY = {XM_PERMUTE_0W, XM_PERMUTE_0Z, XM_PERMUTE_0W, XM_PERMUTE_0Y};
|
|
static CONST XMVECTORU32 Permute0X0Z1X1Z = {XM_PERMUTE_0X, XM_PERMUTE_0Z, XM_PERMUTE_1X, XM_PERMUTE_1Z};
|
|
static CONST XMVECTORU32 Permute0Y0W1Y1W = {XM_PERMUTE_0Y, XM_PERMUTE_0W, XM_PERMUTE_1Y, XM_PERMUTE_1W};
|
|
static CONST XMVECTORU32 Permute1Y0Y0W0X = {XM_PERMUTE_1Y, XM_PERMUTE_0Y, XM_PERMUTE_0W, XM_PERMUTE_0X};
|
|
static CONST XMVECTORU32 Permute0W0X0Y1X = {XM_PERMUTE_0W, XM_PERMUTE_0X, XM_PERMUTE_0Y, XM_PERMUTE_1X};
|
|
static CONST XMVECTORU32 Permute0Z1Y1X0Z = {XM_PERMUTE_0Z, XM_PERMUTE_1Y, XM_PERMUTE_1X, XM_PERMUTE_0Z};
|
|
static CONST XMVECTORU32 Permute0W1Y0Y0Z = {XM_PERMUTE_0W, XM_PERMUTE_1Y, XM_PERMUTE_0Y, XM_PERMUTE_0Z};
|
|
static CONST XMVECTORU32 Permute0Z0Y1X0X = {XM_PERMUTE_0Z, XM_PERMUTE_0Y, XM_PERMUTE_1X, XM_PERMUTE_0X};
|
|
static CONST XMVECTORU32 Permute1Y0X0W1X = {XM_PERMUTE_1Y, XM_PERMUTE_0X, XM_PERMUTE_0W, XM_PERMUTE_1X};
|
|
static CONST XMVECTORU32 Permute1W0Y0W0X = {XM_PERMUTE_1W, XM_PERMUTE_0Y, XM_PERMUTE_0W, XM_PERMUTE_0X};
|
|
static CONST XMVECTORU32 Permute0W0X0Y1Z = {XM_PERMUTE_0W, XM_PERMUTE_0X, XM_PERMUTE_0Y, XM_PERMUTE_1Z};
|
|
static CONST XMVECTORU32 Permute0Z1W1Z0Z = {XM_PERMUTE_0Z, XM_PERMUTE_1W, XM_PERMUTE_1Z, XM_PERMUTE_0Z};
|
|
static CONST XMVECTORU32 Permute0W1W0Y0Z = {XM_PERMUTE_0W, XM_PERMUTE_1W, XM_PERMUTE_0Y, XM_PERMUTE_0Z};
|
|
static CONST XMVECTORU32 Permute0Z0Y1Z0X = {XM_PERMUTE_0Z, XM_PERMUTE_0Y, XM_PERMUTE_1Z, XM_PERMUTE_0X};
|
|
static CONST XMVECTORU32 Permute1W0X0W1Z = {XM_PERMUTE_1W, XM_PERMUTE_0X, XM_PERMUTE_0W, XM_PERMUTE_1Z};
|
|
|
|
XMASSERT(pDeterminant);
|
|
|
|
MT = XMMatrixTranspose(M);
|
|
|
|
V0[0] = XMVectorPermute(MT.r[2], MT.r[2], SwizzleXXYY.v);
|
|
V1[0] = XMVectorPermute(MT.r[3], MT.r[3], SwizzleZWZW.v);
|
|
V0[1] = XMVectorPermute(MT.r[0], MT.r[0], SwizzleXXYY.v);
|
|
V1[1] = XMVectorPermute(MT.r[1], MT.r[1], SwizzleZWZW.v);
|
|
V0[2] = XMVectorPermute(MT.r[2], MT.r[0], Permute0X0Z1X1Z.v);
|
|
V1[2] = XMVectorPermute(MT.r[3], MT.r[1], Permute0Y0W1Y1W.v);
|
|
|
|
D0 = XMVectorMultiply(V0[0], V1[0]);
|
|
D1 = XMVectorMultiply(V0[1], V1[1]);
|
|
D2 = XMVectorMultiply(V0[2], V1[2]);
|
|
|
|
V0[0] = XMVectorPermute(MT.r[2], MT.r[2], SwizzleZWZW.v);
|
|
V1[0] = XMVectorPermute(MT.r[3], MT.r[3], SwizzleXXYY.v);
|
|
V0[1] = XMVectorPermute(MT.r[0], MT.r[0], SwizzleZWZW.v);
|
|
V1[1] = XMVectorPermute(MT.r[1], MT.r[1], SwizzleXXYY.v);
|
|
V0[2] = XMVectorPermute(MT.r[2], MT.r[0], Permute0Y0W1Y1W.v);
|
|
V1[2] = XMVectorPermute(MT.r[3], MT.r[1], Permute0X0Z1X1Z.v);
|
|
|
|
D0 = XMVectorNegativeMultiplySubtract(V0[0], V1[0], D0);
|
|
D1 = XMVectorNegativeMultiplySubtract(V0[1], V1[1], D1);
|
|
D2 = XMVectorNegativeMultiplySubtract(V0[2], V1[2], D2);
|
|
|
|
V0[0] = XMVectorPermute(MT.r[1], MT.r[1], SwizzleYZXY.v);
|
|
V1[0] = XMVectorPermute(D0, D2, Permute1Y0Y0W0X.v);
|
|
V0[1] = XMVectorPermute(MT.r[0], MT.r[0], SwizzleZXYX.v);
|
|
V1[1] = XMVectorPermute(D0, D2, Permute0W1Y0Y0Z.v);
|
|
V0[2] = XMVectorPermute(MT.r[3], MT.r[3], SwizzleYZXY.v);
|
|
V1[2] = XMVectorPermute(D1, D2, Permute1W0Y0W0X.v);
|
|
V0[3] = XMVectorPermute(MT.r[2], MT.r[2], SwizzleZXYX.v);
|
|
V1[3] = XMVectorPermute(D1, D2, Permute0W1W0Y0Z.v);
|
|
|
|
C0 = XMVectorMultiply(V0[0], V1[0]);
|
|
C2 = XMVectorMultiply(V0[1], V1[1]);
|
|
C4 = XMVectorMultiply(V0[2], V1[2]);
|
|
C6 = XMVectorMultiply(V0[3], V1[3]);
|
|
|
|
V0[0] = XMVectorPermute(MT.r[1], MT.r[1], SwizzleZWYZ.v);
|
|
V1[0] = XMVectorPermute(D0, D2, Permute0W0X0Y1X.v);
|
|
V0[1] = XMVectorPermute(MT.r[0], MT.r[0], SwizzleWZWY.v);
|
|
V1[1] = XMVectorPermute(D0, D2, Permute0Z0Y1X0X.v);
|
|
V0[2] = XMVectorPermute(MT.r[3], MT.r[3], SwizzleZWYZ.v);
|
|
V1[2] = XMVectorPermute(D1, D2, Permute0W0X0Y1Z.v);
|
|
V0[3] = XMVectorPermute(MT.r[2], MT.r[2], SwizzleWZWY.v);
|
|
V1[3] = XMVectorPermute(D1, D2, Permute0Z0Y1Z0X.v);
|
|
|
|
C0 = XMVectorNegativeMultiplySubtract(V0[0], V1[0], C0);
|
|
C2 = XMVectorNegativeMultiplySubtract(V0[1], V1[1], C2);
|
|
C4 = XMVectorNegativeMultiplySubtract(V0[2], V1[2], C4);
|
|
C6 = XMVectorNegativeMultiplySubtract(V0[3], V1[3], C6);
|
|
|
|
V0[0] = XMVectorPermute(MT.r[1], MT.r[1], SwizzleWXWX.v);
|
|
V1[0] = XMVectorPermute(D0, D2, Permute0Z1Y1X0Z.v);
|
|
V0[1] = XMVectorPermute(MT.r[0], MT.r[0], SwizzleYWXZ.v);
|
|
V1[1] = XMVectorPermute(D0, D2, Permute1Y0X0W1X.v);
|
|
V0[2] = XMVectorPermute(MT.r[3], MT.r[3], SwizzleWXWX.v);
|
|
V1[2] = XMVectorPermute(D1, D2, Permute0Z1W1Z0Z.v);
|
|
V0[3] = XMVectorPermute(MT.r[2], MT.r[2], SwizzleYWXZ.v);
|
|
V1[3] = XMVectorPermute(D1, D2, Permute1W0X0W1Z.v);
|
|
|
|
C1 = XMVectorNegativeMultiplySubtract(V0[0], V1[0], C0);
|
|
C0 = XMVectorMultiplyAdd(V0[0], V1[0], C0);
|
|
C3 = XMVectorMultiplyAdd(V0[1], V1[1], C2);
|
|
C2 = XMVectorNegativeMultiplySubtract(V0[1], V1[1], C2);
|
|
C5 = XMVectorNegativeMultiplySubtract(V0[2], V1[2], C4);
|
|
C4 = XMVectorMultiplyAdd(V0[2], V1[2], C4);
|
|
C7 = XMVectorMultiplyAdd(V0[3], V1[3], C6);
|
|
C6 = XMVectorNegativeMultiplySubtract(V0[3], V1[3], C6);
|
|
|
|
R.r[0] = XMVectorSelect(C0, C1, g_XMSelect0101.v);
|
|
R.r[1] = XMVectorSelect(C2, C3, g_XMSelect0101.v);
|
|
R.r[2] = XMVectorSelect(C4, C5, g_XMSelect0101.v);
|
|
R.r[3] = XMVectorSelect(C6, C7, g_XMSelect0101.v);
|
|
|
|
Determinant = XMVector4Dot(R.r[0], MT.r[0]);
|
|
|
|
*pDeterminant = Determinant;
|
|
|
|
Reciprocal = XMVectorReciprocal(Determinant);
|
|
|
|
Result.r[0] = XMVectorMultiply(R.r[0], Reciprocal);
|
|
Result.r[1] = XMVectorMultiply(R.r[1], Reciprocal);
|
|
Result.r[2] = XMVectorMultiply(R.r[2], Reciprocal);
|
|
Result.r[3] = XMVectorMultiply(R.r[3], Reciprocal);
|
|
|
|
return Result;
|
|
|
|
#elif defined(_XM_SSE_INTRINSICS_)
|
|
XMASSERT(pDeterminant);
|
|
XMMATRIX MT = XMMatrixTranspose(M);
|
|
XMVECTOR V00 = _mm_shuffle_ps(MT.r[2], MT.r[2],_MM_SHUFFLE(1,1,0,0));
|
|
XMVECTOR V10 = _mm_shuffle_ps(MT.r[3], MT.r[3],_MM_SHUFFLE(3,2,3,2));
|
|
XMVECTOR V01 = _mm_shuffle_ps(MT.r[0], MT.r[0],_MM_SHUFFLE(1,1,0,0));
|
|
XMVECTOR V11 = _mm_shuffle_ps(MT.r[1], MT.r[1],_MM_SHUFFLE(3,2,3,2));
|
|
XMVECTOR V02 = _mm_shuffle_ps(MT.r[2], MT.r[0],_MM_SHUFFLE(2,0,2,0));
|
|
XMVECTOR V12 = _mm_shuffle_ps(MT.r[3], MT.r[1],_MM_SHUFFLE(3,1,3,1));
|
|
|
|
XMVECTOR D0 = _mm_mul_ps(V00,V10);
|
|
XMVECTOR D1 = _mm_mul_ps(V01,V11);
|
|
XMVECTOR D2 = _mm_mul_ps(V02,V12);
|
|
|
|
V00 = _mm_shuffle_ps(MT.r[2],MT.r[2],_MM_SHUFFLE(3,2,3,2));
|
|
V10 = _mm_shuffle_ps(MT.r[3],MT.r[3],_MM_SHUFFLE(1,1,0,0));
|
|
V01 = _mm_shuffle_ps(MT.r[0],MT.r[0],_MM_SHUFFLE(3,2,3,2));
|
|
V11 = _mm_shuffle_ps(MT.r[1],MT.r[1],_MM_SHUFFLE(1,1,0,0));
|
|
V02 = _mm_shuffle_ps(MT.r[2],MT.r[0],_MM_SHUFFLE(3,1,3,1));
|
|
V12 = _mm_shuffle_ps(MT.r[3],MT.r[1],_MM_SHUFFLE(2,0,2,0));
|
|
|
|
V00 = _mm_mul_ps(V00,V10);
|
|
V01 = _mm_mul_ps(V01,V11);
|
|
V02 = _mm_mul_ps(V02,V12);
|
|
D0 = _mm_sub_ps(D0,V00);
|
|
D1 = _mm_sub_ps(D1,V01);
|
|
D2 = _mm_sub_ps(D2,V02);
|
|
// V11 = D0Y,D0W,D2Y,D2Y
|
|
V11 = _mm_shuffle_ps(D0,D2,_MM_SHUFFLE(1,1,3,1));
|
|
V00 = _mm_shuffle_ps(MT.r[1], MT.r[1],_MM_SHUFFLE(1,0,2,1));
|
|
V10 = _mm_shuffle_ps(V11,D0,_MM_SHUFFLE(0,3,0,2));
|
|
V01 = _mm_shuffle_ps(MT.r[0], MT.r[0],_MM_SHUFFLE(0,1,0,2));
|
|
V11 = _mm_shuffle_ps(V11,D0,_MM_SHUFFLE(2,1,2,1));
|
|
// V13 = D1Y,D1W,D2W,D2W
|
|
XMVECTOR V13 = _mm_shuffle_ps(D1,D2,_MM_SHUFFLE(3,3,3,1));
|
|
V02 = _mm_shuffle_ps(MT.r[3], MT.r[3],_MM_SHUFFLE(1,0,2,1));
|
|
V12 = _mm_shuffle_ps(V13,D1,_MM_SHUFFLE(0,3,0,2));
|
|
XMVECTOR V03 = _mm_shuffle_ps(MT.r[2], MT.r[2],_MM_SHUFFLE(0,1,0,2));
|
|
V13 = _mm_shuffle_ps(V13,D1,_MM_SHUFFLE(2,1,2,1));
|
|
|
|
XMVECTOR C0 = _mm_mul_ps(V00,V10);
|
|
XMVECTOR C2 = _mm_mul_ps(V01,V11);
|
|
XMVECTOR C4 = _mm_mul_ps(V02,V12);
|
|
XMVECTOR C6 = _mm_mul_ps(V03,V13);
|
|
|
|
// V11 = D0X,D0Y,D2X,D2X
|
|
V11 = _mm_shuffle_ps(D0,D2,_MM_SHUFFLE(0,0,1,0));
|
|
V00 = _mm_shuffle_ps(MT.r[1], MT.r[1],_MM_SHUFFLE(2,1,3,2));
|
|
V10 = _mm_shuffle_ps(D0,V11,_MM_SHUFFLE(2,1,0,3));
|
|
V01 = _mm_shuffle_ps(MT.r[0], MT.r[0],_MM_SHUFFLE(1,3,2,3));
|
|
V11 = _mm_shuffle_ps(D0,V11,_MM_SHUFFLE(0,2,1,2));
|
|
// V13 = D1X,D1Y,D2Z,D2Z
|
|
V13 = _mm_shuffle_ps(D1,D2,_MM_SHUFFLE(2,2,1,0));
|
|
V02 = _mm_shuffle_ps(MT.r[3], MT.r[3],_MM_SHUFFLE(2,1,3,2));
|
|
V12 = _mm_shuffle_ps(D1,V13,_MM_SHUFFLE(2,1,0,3));
|
|
V03 = _mm_shuffle_ps(MT.r[2], MT.r[2],_MM_SHUFFLE(1,3,2,3));
|
|
V13 = _mm_shuffle_ps(D1,V13,_MM_SHUFFLE(0,2,1,2));
|
|
|
|
V00 = _mm_mul_ps(V00,V10);
|
|
V01 = _mm_mul_ps(V01,V11);
|
|
V02 = _mm_mul_ps(V02,V12);
|
|
V03 = _mm_mul_ps(V03,V13);
|
|
C0 = _mm_sub_ps(C0,V00);
|
|
C2 = _mm_sub_ps(C2,V01);
|
|
C4 = _mm_sub_ps(C4,V02);
|
|
C6 = _mm_sub_ps(C6,V03);
|
|
|
|
V00 = _mm_shuffle_ps(MT.r[1],MT.r[1],_MM_SHUFFLE(0,3,0,3));
|
|
// V10 = D0Z,D0Z,D2X,D2Y
|
|
V10 = _mm_shuffle_ps(D0,D2,_MM_SHUFFLE(1,0,2,2));
|
|
V10 = _mm_shuffle_ps(V10,V10,_MM_SHUFFLE(0,2,3,0));
|
|
V01 = _mm_shuffle_ps(MT.r[0],MT.r[0],_MM_SHUFFLE(2,0,3,1));
|
|
// V11 = D0X,D0W,D2X,D2Y
|
|
V11 = _mm_shuffle_ps(D0,D2,_MM_SHUFFLE(1,0,3,0));
|
|
V11 = _mm_shuffle_ps(V11,V11,_MM_SHUFFLE(2,1,0,3));
|
|
V02 = _mm_shuffle_ps(MT.r[3],MT.r[3],_MM_SHUFFLE(0,3,0,3));
|
|
// V12 = D1Z,D1Z,D2Z,D2W
|
|
V12 = _mm_shuffle_ps(D1,D2,_MM_SHUFFLE(3,2,2,2));
|
|
V12 = _mm_shuffle_ps(V12,V12,_MM_SHUFFLE(0,2,3,0));
|
|
V03 = _mm_shuffle_ps(MT.r[2],MT.r[2],_MM_SHUFFLE(2,0,3,1));
|
|
// V13 = D1X,D1W,D2Z,D2W
|
|
V13 = _mm_shuffle_ps(D1,D2,_MM_SHUFFLE(3,2,3,0));
|
|
V13 = _mm_shuffle_ps(V13,V13,_MM_SHUFFLE(2,1,0,3));
|
|
|
|
V00 = _mm_mul_ps(V00,V10);
|
|
V01 = _mm_mul_ps(V01,V11);
|
|
V02 = _mm_mul_ps(V02,V12);
|
|
V03 = _mm_mul_ps(V03,V13);
|
|
XMVECTOR C1 = _mm_sub_ps(C0,V00);
|
|
C0 = _mm_add_ps(C0,V00);
|
|
XMVECTOR C3 = _mm_add_ps(C2,V01);
|
|
C2 = _mm_sub_ps(C2,V01);
|
|
XMVECTOR C5 = _mm_sub_ps(C4,V02);
|
|
C4 = _mm_add_ps(C4,V02);
|
|
XMVECTOR C7 = _mm_add_ps(C6,V03);
|
|
C6 = _mm_sub_ps(C6,V03);
|
|
|
|
C0 = _mm_shuffle_ps(C0,C1,_MM_SHUFFLE(3,1,2,0));
|
|
C2 = _mm_shuffle_ps(C2,C3,_MM_SHUFFLE(3,1,2,0));
|
|
C4 = _mm_shuffle_ps(C4,C5,_MM_SHUFFLE(3,1,2,0));
|
|
C6 = _mm_shuffle_ps(C6,C7,_MM_SHUFFLE(3,1,2,0));
|
|
C0 = _mm_shuffle_ps(C0,C0,_MM_SHUFFLE(3,1,2,0));
|
|
C2 = _mm_shuffle_ps(C2,C2,_MM_SHUFFLE(3,1,2,0));
|
|
C4 = _mm_shuffle_ps(C4,C4,_MM_SHUFFLE(3,1,2,0));
|
|
C6 = _mm_shuffle_ps(C6,C6,_MM_SHUFFLE(3,1,2,0));
|
|
// Get the determinate
|
|
XMVECTOR vTemp = XMVector4Dot(C0,MT.r[0]);
|
|
*pDeterminant = vTemp;
|
|
vTemp = _mm_div_ps(g_XMOne,vTemp);
|
|
XMMATRIX mResult;
|
|
mResult.r[0] = _mm_mul_ps(C0,vTemp);
|
|
mResult.r[1] = _mm_mul_ps(C2,vTemp);
|
|
mResult.r[2] = _mm_mul_ps(C4,vTemp);
|
|
mResult.r[3] = _mm_mul_ps(C6,vTemp);
|
|
return mResult;
|
|
#else // _XM_VMX128_INTRINSICS_
|
|
#endif // _XM_VMX128_INTRINSICS_
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
XMINLINE XMVECTOR XMMatrixDeterminant
|
|
(
|
|
CXMMATRIX M
|
|
)
|
|
{
|
|
#if defined(_XM_NO_INTRINSICS_)
|
|
|
|
XMVECTOR V0, V1, V2, V3, V4, V5;
|
|
XMVECTOR P0, P1, P2, R, S;
|
|
XMVECTOR Result;
|
|
static CONST XMVECTORU32 SwizzleYXXX = {XM_PERMUTE_0Y, XM_PERMUTE_0X, XM_PERMUTE_0X, XM_PERMUTE_0X};
|
|
static CONST XMVECTORU32 SwizzleZZYY = {XM_PERMUTE_0Z, XM_PERMUTE_0Z, XM_PERMUTE_0Y, XM_PERMUTE_0Y};
|
|
static CONST XMVECTORU32 SwizzleWWWZ = {XM_PERMUTE_0W, XM_PERMUTE_0W, XM_PERMUTE_0W, XM_PERMUTE_0Z};
|
|
static CONST XMVECTOR Sign = {1.0f, -1.0f, 1.0f, -1.0f};
|
|
|
|
V0 = XMVectorPermute(M.r[2], M.r[2], SwizzleYXXX.v);
|
|
V1 = XMVectorPermute(M.r[3], M.r[3], SwizzleZZYY.v);
|
|
V2 = XMVectorPermute(M.r[2], M.r[2], SwizzleYXXX.v);
|
|
V3 = XMVectorPermute(M.r[3], M.r[3], SwizzleWWWZ.v);
|
|
V4 = XMVectorPermute(M.r[2], M.r[2], SwizzleZZYY.v);
|
|
V5 = XMVectorPermute(M.r[3], M.r[3], SwizzleWWWZ.v);
|
|
|
|
P0 = XMVectorMultiply(V0, V1);
|
|
P1 = XMVectorMultiply(V2, V3);
|
|
P2 = XMVectorMultiply(V4, V5);
|
|
|
|
V0 = XMVectorPermute(M.r[2], M.r[2], SwizzleZZYY.v);
|
|
V1 = XMVectorPermute(M.r[3], M.r[3], SwizzleYXXX.v);
|
|
V2 = XMVectorPermute(M.r[2], M.r[2], SwizzleWWWZ.v);
|
|
V3 = XMVectorPermute(M.r[3], M.r[3], SwizzleYXXX.v);
|
|
V4 = XMVectorPermute(M.r[2], M.r[2], SwizzleWWWZ.v);
|
|
V5 = XMVectorPermute(M.r[3], M.r[3], SwizzleZZYY.v);
|
|
|
|
P0 = XMVectorNegativeMultiplySubtract(V0, V1, P0);
|
|
P1 = XMVectorNegativeMultiplySubtract(V2, V3, P1);
|
|
P2 = XMVectorNegativeMultiplySubtract(V4, V5, P2);
|
|
|
|
V0 = XMVectorPermute(M.r[1], M.r[1], SwizzleWWWZ.v);
|
|
V1 = XMVectorPermute(M.r[1], M.r[1], SwizzleZZYY.v);
|
|
V2 = XMVectorPermute(M.r[1], M.r[1], SwizzleYXXX.v);
|
|
|
|
S = XMVectorMultiply(M.r[0], Sign);
|
|
R = XMVectorMultiply(V0, P0);
|
|
R = XMVectorNegativeMultiplySubtract(V1, P1, R);
|
|
R = XMVectorMultiplyAdd(V2, P2, R);
|
|
|
|
Result = XMVector4Dot(S, R);
|
|
|
|
return Result;
|
|
|
|
#elif defined(_XM_SSE_INTRINSICS_)
|
|
XMVECTOR V0, V1, V2, V3, V4, V5;
|
|
XMVECTOR P0, P1, P2, R, S;
|
|
XMVECTOR Result;
|
|
static CONST XMVECTORU32 SwizzleYXXX = {XM_PERMUTE_0Y, XM_PERMUTE_0X, XM_PERMUTE_0X, XM_PERMUTE_0X};
|
|
static CONST XMVECTORU32 SwizzleZZYY = {XM_PERMUTE_0Z, XM_PERMUTE_0Z, XM_PERMUTE_0Y, XM_PERMUTE_0Y};
|
|
static CONST XMVECTORU32 SwizzleWWWZ = {XM_PERMUTE_0W, XM_PERMUTE_0W, XM_PERMUTE_0W, XM_PERMUTE_0Z};
|
|
static CONST XMVECTORF32 Sign = {1.0f, -1.0f, 1.0f, -1.0f};
|
|
|
|
V0 = XMVectorPermute(M.r[2], M.r[2], SwizzleYXXX);
|
|
V1 = XMVectorPermute(M.r[3], M.r[3], SwizzleZZYY);
|
|
V2 = XMVectorPermute(M.r[2], M.r[2], SwizzleYXXX);
|
|
V3 = XMVectorPermute(M.r[3], M.r[3], SwizzleWWWZ);
|
|
V4 = XMVectorPermute(M.r[2], M.r[2], SwizzleZZYY);
|
|
V5 = XMVectorPermute(M.r[3], M.r[3], SwizzleWWWZ);
|
|
|
|
P0 = _mm_mul_ps(V0, V1);
|
|
P1 = _mm_mul_ps(V2, V3);
|
|
P2 = _mm_mul_ps(V4, V5);
|
|
|
|
V0 = XMVectorPermute(M.r[2], M.r[2], SwizzleZZYY);
|
|
V1 = XMVectorPermute(M.r[3], M.r[3], SwizzleYXXX);
|
|
V2 = XMVectorPermute(M.r[2], M.r[2], SwizzleWWWZ);
|
|
V3 = XMVectorPermute(M.r[3], M.r[3], SwizzleYXXX);
|
|
V4 = XMVectorPermute(M.r[2], M.r[2], SwizzleWWWZ);
|
|
V5 = XMVectorPermute(M.r[3], M.r[3], SwizzleZZYY);
|
|
|
|
P0 = XMVectorNegativeMultiplySubtract(V0, V1, P0);
|
|
P1 = XMVectorNegativeMultiplySubtract(V2, V3, P1);
|
|
P2 = XMVectorNegativeMultiplySubtract(V4, V5, P2);
|
|
|
|
V0 = XMVectorPermute(M.r[1], M.r[1], SwizzleWWWZ);
|
|
V1 = XMVectorPermute(M.r[1], M.r[1], SwizzleZZYY);
|
|
V2 = XMVectorPermute(M.r[1], M.r[1], SwizzleYXXX);
|
|
|
|
S = _mm_mul_ps(M.r[0], Sign);
|
|
R = _mm_mul_ps(V0, P0);
|
|
R = XMVectorNegativeMultiplySubtract(V1, P1, R);
|
|
R = XMVectorMultiplyAdd(V2, P2, R);
|
|
|
|
Result = XMVector4Dot(S, R);
|
|
|
|
return Result;
|
|
|
|
#else // _XM_VMX128_INTRINSICS_
|
|
#endif // _XM_VMX128_INTRINSICS_
|
|
}
|
|
|
|
#define XMRANKDECOMPOSE(a, b, c, x, y, z) \
|
|
if((x) < (y)) \
|
|
{ \
|
|
if((y) < (z)) \
|
|
{ \
|
|
(a) = 2; \
|
|
(b) = 1; \
|
|
(c) = 0; \
|
|
} \
|
|
else \
|
|
{ \
|
|
(a) = 1; \
|
|
\
|
|
if((x) < (z)) \
|
|
{ \
|
|
(b) = 2; \
|
|
(c) = 0; \
|
|
} \
|
|
else \
|
|
{ \
|
|
(b) = 0; \
|
|
(c) = 2; \
|
|
} \
|
|
} \
|
|
} \
|
|
else \
|
|
{ \
|
|
if((x) < (z)) \
|
|
{ \
|
|
(a) = 2; \
|
|
(b) = 0; \
|
|
(c) = 1; \
|
|
} \
|
|
else \
|
|
{ \
|
|
(a) = 0; \
|
|
\
|
|
if((y) < (z)) \
|
|
{ \
|
|
(b) = 2; \
|
|
(c) = 1; \
|
|
} \
|
|
else \
|
|
{ \
|
|
(b) = 1; \
|
|
(c) = 2; \
|
|
} \
|
|
} \
|
|
}
|
|
|
|
#define XM_DECOMP_EPSILON 0.0001f
|
|
|
|
XMINLINE BOOL XMMatrixDecompose( XMVECTOR *outScale, XMVECTOR *outRotQuat, XMVECTOR *outTrans, CXMMATRIX M )
|
|
{
|
|
FLOAT fDet;
|
|
FLOAT *pfScales;
|
|
XMVECTOR *ppvBasis[3];
|
|
XMMATRIX matTemp;
|
|
UINT a, b, c;
|
|
static const XMVECTOR *pvCanonicalBasis[3] = {
|
|
&g_XMIdentityR0.v,
|
|
&g_XMIdentityR1.v,
|
|
&g_XMIdentityR2.v
|
|
};
|
|
|
|
// Get the translation
|
|
outTrans[0] = M.r[3];
|
|
|
|
ppvBasis[0] = &matTemp.r[0];
|
|
ppvBasis[1] = &matTemp.r[1];
|
|
ppvBasis[2] = &matTemp.r[2];
|
|
|
|
matTemp.r[0] = M.r[0];
|
|
matTemp.r[1] = M.r[1];
|
|
matTemp.r[2] = M.r[2];
|
|
matTemp.r[3] = g_XMIdentityR3.v;
|
|
|
|
pfScales = (FLOAT *)outScale;
|
|
|
|
XMVectorGetXPtr(&pfScales[0],XMVector3Length(ppvBasis[0][0]));
|
|
XMVectorGetXPtr(&pfScales[1],XMVector3Length(ppvBasis[1][0]));
|
|
XMVectorGetXPtr(&pfScales[2],XMVector3Length(ppvBasis[2][0]));
|
|
|
|
XMRANKDECOMPOSE(a, b, c, pfScales[0], pfScales[1], pfScales[2])
|
|
|
|
if(pfScales[a] < XM_DECOMP_EPSILON)
|
|
{
|
|
ppvBasis[a][0] = pvCanonicalBasis[a][0];
|
|
}
|
|
ppvBasis[a][0] = XMVector3Normalize(ppvBasis[a][0]);
|
|
|
|
if(pfScales[b] < XM_DECOMP_EPSILON)
|
|
{
|
|
UINT aa, bb, cc;
|
|
FLOAT fAbsX, fAbsY, fAbsZ;
|
|
|
|
fAbsX = fabsf(XMVectorGetX(ppvBasis[a][0]));
|
|
fAbsY = fabsf(XMVectorGetY(ppvBasis[a][0]));
|
|
fAbsZ = fabsf(XMVectorGetZ(ppvBasis[a][0]));
|
|
|
|
XMRANKDECOMPOSE(aa, bb, cc, fAbsX, fAbsY, fAbsZ)
|
|
|
|
ppvBasis[b][0] = XMVector3Cross(ppvBasis[a][0],pvCanonicalBasis[cc][0]);
|
|
}
|
|
|
|
ppvBasis[b][0] = XMVector3Normalize(ppvBasis[b][0]);
|
|
|
|
if(pfScales[c] < XM_DECOMP_EPSILON)
|
|
{
|
|
ppvBasis[c][0] = XMVector3Cross(ppvBasis[a][0],ppvBasis[b][0]);
|
|
}
|
|
|
|
ppvBasis[c][0] = XMVector3Normalize(ppvBasis[c][0]);
|
|
|
|
fDet = XMVectorGetX(XMMatrixDeterminant(matTemp));
|
|
|
|
// use Kramer's rule to check for handedness of coordinate system
|
|
if(fDet < 0.0f)
|
|
{
|
|
// switch coordinate system by negating the scale and inverting the basis vector on the x-axis
|
|
pfScales[a] = -pfScales[a];
|
|
ppvBasis[a][0] = XMVectorNegate(ppvBasis[a][0]);
|
|
|
|
fDet = -fDet;
|
|
}
|
|
|
|
fDet -= 1.0f;
|
|
fDet *= fDet;
|
|
|
|
if(XM_DECOMP_EPSILON < fDet)
|
|
{
|
|
// Non-SRT matrix encountered
|
|
return FALSE;
|
|
}
|
|
|
|
// generate the quaternion from the matrix
|
|
outRotQuat[0] = XMQuaternionRotationMatrix(matTemp);
|
|
return TRUE;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Transformation operations
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
XMFINLINE XMMATRIX XMMatrixIdentity()
|
|
{
|
|
#if defined(_XM_NO_INTRINSICS_)
|
|
|
|
XMMATRIX M;
|
|
M.r[0] = g_XMIdentityR0.v;
|
|
M.r[1] = g_XMIdentityR1.v;
|
|
M.r[2] = g_XMIdentityR2.v;
|
|
M.r[3] = g_XMIdentityR3.v;
|
|
return M;
|
|
|
|
#elif defined(_XM_SSE_INTRINSICS_)
|
|
XMMATRIX M;
|
|
M.r[0] = g_XMIdentityR0;
|
|
M.r[1] = g_XMIdentityR1;
|
|
M.r[2] = g_XMIdentityR2;
|
|
M.r[3] = g_XMIdentityR3;
|
|
return M;
|
|
#else // _XM_VMX128_INTRINSICS_
|
|
#endif // _XM_VMX128_INTRINSICS_
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
XMFINLINE XMMATRIX XMMatrixSet
|
|
(
|
|
FLOAT m00, FLOAT m01, FLOAT m02, FLOAT m03,
|
|
FLOAT m10, FLOAT m11, FLOAT m12, FLOAT m13,
|
|
FLOAT m20, FLOAT m21, FLOAT m22, FLOAT m23,
|
|
FLOAT m30, FLOAT m31, FLOAT m32, FLOAT m33
|
|
)
|
|
{
|
|
XMMATRIX M;
|
|
|
|
M.r[0] = XMVectorSet(m00, m01, m02, m03);
|
|
M.r[1] = XMVectorSet(m10, m11, m12, m13);
|
|
M.r[2] = XMVectorSet(m20, m21, m22, m23);
|
|
M.r[3] = XMVectorSet(m30, m31, m32, m33);
|
|
|
|
return M;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
XMFINLINE XMMATRIX XMMatrixTranslation
|
|
(
|
|
FLOAT OffsetX,
|
|
FLOAT OffsetY,
|
|
FLOAT OffsetZ
|
|
)
|
|
{
|
|
#if defined(_XM_NO_INTRINSICS_)
|
|
|
|
XMMATRIX M;
|
|
|
|
M.m[0][0] = 1.0f;
|
|
M.m[0][1] = 0.0f;
|
|
M.m[0][2] = 0.0f;
|
|
M.m[0][3] = 0.0f;
|
|
|
|
M.m[1][0] = 0.0f;
|
|
M.m[1][1] = 1.0f;
|
|
M.m[1][2] = 0.0f;
|
|
M.m[1][3] = 0.0f;
|
|
|
|
M.m[2][0] = 0.0f;
|
|
M.m[2][1] = 0.0f;
|
|
M.m[2][2] = 1.0f;
|
|
M.m[2][3] = 0.0f;
|
|
|
|
M.m[3][0] = OffsetX;
|
|
M.m[3][1] = OffsetY;
|
|
M.m[3][2] = OffsetZ;
|
|
M.m[3][3] = 1.0f;
|
|
return M;
|
|
|
|
#elif defined(_XM_SSE_INTRINSICS_)
|
|
XMMATRIX M;
|
|
M.r[0] = g_XMIdentityR0;
|
|
M.r[1] = g_XMIdentityR1;
|
|
M.r[2] = g_XMIdentityR2;
|
|
M.r[3] = _mm_set_ps(1.0f,OffsetZ,OffsetY,OffsetX);
|
|
return M;
|
|
#else // _XM_VMX128_INTRINSICS_
|
|
#endif // _XM_VMX128_INTRINSICS_
|
|
}
|
|
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
XMFINLINE XMMATRIX XMMatrixTranslationFromVector
|
|
(
|
|
FXMVECTOR Offset
|
|
)
|
|
{
|
|
#if defined(_XM_NO_INTRINSICS_)
|
|
|
|
XMMATRIX M;
|
|
M.m[0][0] = 1.0f;
|
|
M.m[0][1] = 0.0f;
|
|
M.m[0][2] = 0.0f;
|
|
M.m[0][3] = 0.0f;
|
|
|
|
M.m[1][0] = 0.0f;
|
|
M.m[1][1] = 1.0f;
|
|
M.m[1][2] = 0.0f;
|
|
M.m[1][3] = 0.0f;
|
|
|
|
M.m[2][0] = 0.0f;
|
|
M.m[2][1] = 0.0f;
|
|
M.m[2][2] = 1.0f;
|
|
M.m[2][3] = 0.0f;
|
|
|
|
M.m[3][0] = Offset.vector4_f32[0];
|
|
M.m[3][1] = Offset.vector4_f32[1];
|
|
M.m[3][2] = Offset.vector4_f32[2];
|
|
M.m[3][3] = 1.0f;
|
|
return M;
|
|
|
|
#elif defined(_XM_SSE_INTRINSICS_)
|
|
XMVECTOR vTemp = _mm_and_ps(Offset,g_XMMask3);
|
|
vTemp = _mm_or_ps(vTemp,g_XMIdentityR3);
|
|
XMMATRIX M;
|
|
M.r[0] = g_XMIdentityR0;
|
|
M.r[1] = g_XMIdentityR1;
|
|
M.r[2] = g_XMIdentityR2;
|
|
M.r[3] = vTemp;
|
|
return M;
|
|
#else // _XM_VMX128_INTRINSICS_
|
|
#endif // _XM_VMX128_INTRINSICS_
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
XMFINLINE XMMATRIX XMMatrixScaling
|
|
(
|
|
FLOAT ScaleX,
|
|
FLOAT ScaleY,
|
|
FLOAT ScaleZ
|
|
)
|
|
{
|
|
#if defined(_XM_NO_INTRINSICS_)
|
|
|
|
XMMATRIX M;
|
|
|
|
M.r[0] = XMVectorSet(ScaleX, 0.0f, 0.0f, 0.0f);
|
|
M.r[1] = XMVectorSet(0.0f, ScaleY, 0.0f, 0.0f);
|
|
M.r[2] = XMVectorSet(0.0f, 0.0f, ScaleZ, 0.0f);
|
|
|
|
M.r[3] = g_XMIdentityR3.v;
|
|
|
|
return M;
|
|
|
|
#elif defined(_XM_SSE_INTRINSICS_)
|
|
XMMATRIX M;
|
|
M.r[0] = _mm_set_ps( 0, 0, 0, ScaleX );
|
|
M.r[1] = _mm_set_ps( 0, 0, ScaleY, 0 );
|
|
M.r[2] = _mm_set_ps( 0, ScaleZ, 0, 0 );
|
|
M.r[3] = g_XMIdentityR3;
|
|
return M;
|
|
#elif defined(XM_NO_MISALIGNED_VECTOR_ACCESS)
|
|
#endif // _XM_VMX128_INTRINSICS_
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
XMFINLINE XMMATRIX XMMatrixScalingFromVector
|
|
(
|
|
FXMVECTOR Scale
|
|
)
|
|
{
|
|
#if defined(_XM_NO_INTRINSICS_)
|
|
XMMATRIX M;
|
|
M.m[0][0] = Scale.vector4_f32[0];
|
|
M.m[0][1] = 0.0f;
|
|
M.m[0][2] = 0.0f;
|
|
M.m[0][3] = 0.0f;
|
|
|
|
M.m[1][0] = 0.0f;
|
|
M.m[1][1] = Scale.vector4_f32[1];
|
|
M.m[1][2] = 0.0f;
|
|
M.m[1][3] = 0.0f;
|
|
|
|
M.m[2][0] = 0.0f;
|
|
M.m[2][1] = 0.0f;
|
|
M.m[2][2] = Scale.vector4_f32[2];
|
|
M.m[2][3] = 0.0f;
|
|
|
|
M.m[3][0] = 0.0f;
|
|
M.m[3][1] = 0.0f;
|
|
M.m[3][2] = 0.0f;
|
|
M.m[3][3] = 1.0f;
|
|
return M;
|
|
|
|
#elif defined(_XM_SSE_INTRINSICS_)
|
|
XMMATRIX M;
|
|
M.r[0] = _mm_and_ps(Scale,g_XMMaskX);
|
|
M.r[1] = _mm_and_ps(Scale,g_XMMaskY);
|
|
M.r[2] = _mm_and_ps(Scale,g_XMMaskZ);
|
|
M.r[3] = g_XMIdentityR3;
|
|
return M;
|
|
#else // _XM_VMX128_INTRINSICS_
|
|
#endif // _XM_VMX128_INTRINSICS_
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
XMINLINE XMMATRIX XMMatrixRotationX
|
|
(
|
|
FLOAT Angle
|
|
)
|
|
{
|
|
#if defined(_XM_NO_INTRINSICS_)
|
|
XMMATRIX M;
|
|
|
|
FLOAT fSinAngle = sinf(Angle);
|
|
FLOAT fCosAngle = cosf(Angle);
|
|
|
|
M.m[0][0] = 1.0f;
|
|
M.m[0][1] = 0.0f;
|
|
M.m[0][2] = 0.0f;
|
|
M.m[0][3] = 0.0f;
|
|
|
|
M.m[1][0] = 0.0f;
|
|
M.m[1][1] = fCosAngle;
|
|
M.m[1][2] = fSinAngle;
|
|
M.m[1][3] = 0.0f;
|
|
|
|
M.m[2][0] = 0.0f;
|
|
M.m[2][1] = -fSinAngle;
|
|
M.m[2][2] = fCosAngle;
|
|
M.m[2][3] = 0.0f;
|
|
|
|
M.m[3][0] = 0.0f;
|
|
M.m[3][1] = 0.0f;
|
|
M.m[3][2] = 0.0f;
|
|
M.m[3][3] = 1.0f;
|
|
return M;
|
|
|
|
#elif defined(_XM_SSE_INTRINSICS_)
|
|
FLOAT SinAngle = sinf(Angle);
|
|
FLOAT CosAngle = cosf(Angle);
|
|
|
|
XMVECTOR vSin = _mm_set_ss(SinAngle);
|
|
XMVECTOR vCos = _mm_set_ss(CosAngle);
|
|
// x = 0,y = cos,z = sin, w = 0
|
|
vCos = _mm_shuffle_ps(vCos,vSin,_MM_SHUFFLE(3,0,0,3));
|
|
XMMATRIX M;
|
|
M.r[0] = g_XMIdentityR0;
|
|
M.r[1] = vCos;
|
|
// x = 0,y = sin,z = cos, w = 0
|
|
vCos = _mm_shuffle_ps(vCos,vCos,_MM_SHUFFLE(3,1,2,0));
|
|
// x = 0,y = -sin,z = cos, w = 0
|
|
vCos = _mm_mul_ps(vCos,g_XMNegateY);
|
|
M.r[2] = vCos;
|
|
M.r[3] = g_XMIdentityR3;
|
|
return M;
|
|
#else // _XM_VMX128_INTRINSICS_
|
|
#endif // _XM_VMX128_INTRINSICS_
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
XMINLINE XMMATRIX XMMatrixRotationY
|
|
(
|
|
FLOAT Angle
|
|
)
|
|
{
|
|
#if defined(_XM_NO_INTRINSICS_)
|
|
XMMATRIX M;
|
|
|
|
FLOAT fSinAngle = sinf(Angle);
|
|
FLOAT fCosAngle = cosf(Angle);
|
|
|
|
M.m[0][0] = fCosAngle;
|
|
M.m[0][1] = 0.0f;
|
|
M.m[0][2] = -fSinAngle;
|
|
M.m[0][3] = 0.0f;
|
|
|
|
M.m[1][0] = 0.0f;
|
|
M.m[1][1] = 1.0f;
|
|
M.m[1][2] = 0.0f;
|
|
M.m[1][3] = 0.0f;
|
|
|
|
M.m[2][0] = fSinAngle;
|
|
M.m[2][1] = 0.0f;
|
|
M.m[2][2] = fCosAngle;
|
|
M.m[2][3] = 0.0f;
|
|
|
|
M.m[3][0] = 0.0f;
|
|
M.m[3][1] = 0.0f;
|
|
M.m[3][2] = 0.0f;
|
|
M.m[3][3] = 1.0f;
|
|
return M;
|
|
#elif defined(_XM_SSE_INTRINSICS_)
|
|
FLOAT SinAngle = sinf(Angle);
|
|
FLOAT CosAngle = cosf(Angle);
|
|
|
|
XMVECTOR vSin = _mm_set_ss(SinAngle);
|
|
XMVECTOR vCos = _mm_set_ss(CosAngle);
|
|
// x = sin,y = 0,z = cos, w = 0
|
|
vSin = _mm_shuffle_ps(vSin,vCos,_MM_SHUFFLE(3,0,3,0));
|
|
XMMATRIX M;
|
|
M.r[2] = vSin;
|
|
M.r[1] = g_XMIdentityR1;
|
|
// x = cos,y = 0,z = sin, w = 0
|
|
vSin = _mm_shuffle_ps(vSin,vSin,_MM_SHUFFLE(3,0,1,2));
|
|
// x = cos,y = 0,z = -sin, w = 0
|
|
vSin = _mm_mul_ps(vSin,g_XMNegateZ);
|
|
M.r[0] = vSin;
|
|
M.r[3] = g_XMIdentityR3;
|
|
return M;
|
|
#else // _XM_VMX128_INTRINSICS_
|
|
#endif // _XM_VMX128_INTRINSICS_
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
XMINLINE XMMATRIX XMMatrixRotationZ
|
|
(
|
|
FLOAT Angle
|
|
)
|
|
{
|
|
#if defined(_XM_NO_INTRINSICS_)
|
|
XMMATRIX M;
|
|
|
|
FLOAT fSinAngle = sinf(Angle);
|
|
FLOAT fCosAngle = cosf(Angle);
|
|
|
|
M.m[0][0] = fCosAngle;
|
|
M.m[0][1] = fSinAngle;
|
|
M.m[0][2] = 0.0f;
|
|
M.m[0][3] = 0.0f;
|
|
|
|
M.m[1][0] = -fSinAngle;
|
|
M.m[1][1] = fCosAngle;
|
|
M.m[1][2] = 0.0f;
|
|
M.m[1][3] = 0.0f;
|
|
|
|
M.m[2][0] = 0.0f;
|
|
M.m[2][1] = 0.0f;
|
|
M.m[2][2] = 1.0f;
|
|
M.m[2][3] = 0.0f;
|
|
|
|
M.m[3][0] = 0.0f;
|
|
M.m[3][1] = 0.0f;
|
|
M.m[3][2] = 0.0f;
|
|
M.m[3][3] = 1.0f;
|
|
return M;
|
|
|
|
#elif defined(_XM_SSE_INTRINSICS_)
|
|
FLOAT SinAngle = sinf(Angle);
|
|
FLOAT CosAngle = cosf(Angle);
|
|
|
|
XMVECTOR vSin = _mm_set_ss(SinAngle);
|
|
XMVECTOR vCos = _mm_set_ss(CosAngle);
|
|
// x = cos,y = sin,z = 0, w = 0
|
|
vCos = _mm_unpacklo_ps(vCos,vSin);
|
|
XMMATRIX M;
|
|
M.r[0] = vCos;
|
|
// x = sin,y = cos,z = 0, w = 0
|
|
vCos = _mm_shuffle_ps(vCos,vCos,_MM_SHUFFLE(3,2,0,1));
|
|
// x = cos,y = -sin,z = 0, w = 0
|
|
vCos = _mm_mul_ps(vCos,g_XMNegateX);
|
|
M.r[1] = vCos;
|
|
M.r[2] = g_XMIdentityR2;
|
|
M.r[3] = g_XMIdentityR3;
|
|
return M;
|
|
#else // _XM_VMX128_INTRINSICS_
|
|
#endif // _XM_VMX128_INTRINSICS_
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
XMINLINE XMMATRIX XMMatrixRotationRollPitchYaw
|
|
(
|
|
FLOAT Pitch,
|
|
FLOAT Yaw,
|
|
FLOAT Roll
|
|
)
|
|
{
|
|
XMVECTOR Angles;
|
|
XMMATRIX M;
|
|
|
|
Angles = XMVectorSet(Pitch, Yaw, Roll, 0.0f);
|
|
M = XMMatrixRotationRollPitchYawFromVector(Angles);
|
|
|
|
return M;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
XMINLINE XMMATRIX XMMatrixRotationRollPitchYawFromVector
|
|
(
|
|
FXMVECTOR Angles // <Pitch, Yaw, Roll, undefined>
|
|
)
|
|
{
|
|
XMVECTOR Q;
|
|
XMMATRIX M;
|
|
|
|
Q = XMQuaternionRotationRollPitchYawFromVector(Angles);
|
|
M = XMMatrixRotationQuaternion(Q);
|
|
|
|
return M;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
XMINLINE XMMATRIX XMMatrixRotationNormal
|
|
(
|
|
FXMVECTOR NormalAxis,
|
|
FLOAT Angle
|
|
)
|
|
{
|
|
#if defined(_XM_NO_INTRINSICS_)
|
|
XMVECTOR A;
|
|
XMVECTOR N0, N1;
|
|
XMVECTOR V0, V1, V2;
|
|
XMVECTOR R0, R1, R2;
|
|
XMVECTOR C0, C1, C2;
|
|
XMMATRIX M;
|
|
static CONST XMVECTORU32 SwizzleYZXW = {XM_PERMUTE_0Y, XM_PERMUTE_0Z, XM_PERMUTE_0X, XM_PERMUTE_0W};
|
|
static CONST XMVECTORU32 SwizzleZXYW = {XM_PERMUTE_0Z, XM_PERMUTE_0X, XM_PERMUTE_0Y, XM_PERMUTE_0W};
|
|
static CONST XMVECTORU32 Permute0Z1Y1Z0X = {XM_PERMUTE_0Z, XM_PERMUTE_1Y, XM_PERMUTE_1Z, XM_PERMUTE_0X};
|
|
static CONST XMVECTORU32 Permute0Y1X0Y1X = {XM_PERMUTE_0Y, XM_PERMUTE_1X, XM_PERMUTE_0Y, XM_PERMUTE_1X};
|
|
static CONST XMVECTORU32 Permute0X1X1Y0W = {XM_PERMUTE_0X, XM_PERMUTE_1X, XM_PERMUTE_1Y, XM_PERMUTE_0W};
|
|
static CONST XMVECTORU32 Permute1Z0Y1W0W = {XM_PERMUTE_1Z, XM_PERMUTE_0Y, XM_PERMUTE_1W, XM_PERMUTE_0W};
|
|
static CONST XMVECTORU32 Permute1X1Y0Z0W = {XM_PERMUTE_1X, XM_PERMUTE_1Y, XM_PERMUTE_0Z, XM_PERMUTE_0W};
|
|
|
|
FLOAT fSinAngle = sinf(Angle);
|
|
FLOAT fCosAngle = cosf(Angle);
|
|
|
|
A = XMVectorSet(fSinAngle, fCosAngle, 1.0f - fCosAngle, 0.0f);
|
|
|
|
C2 = XMVectorSplatZ(A);
|
|
C1 = XMVectorSplatY(A);
|
|
C0 = XMVectorSplatX(A);
|
|
|
|
N0 = XMVectorPermute(NormalAxis, NormalAxis, SwizzleYZXW.v);
|
|
N1 = XMVectorPermute(NormalAxis, NormalAxis, SwizzleZXYW.v);
|
|
|
|
V0 = XMVectorMultiply(C2, N0);
|
|
V0 = XMVectorMultiply(V0, N1);
|
|
|
|
R0 = XMVectorMultiply(C2, NormalAxis);
|
|
R0 = XMVectorMultiplyAdd(R0, NormalAxis, C1);
|
|
|
|
R1 = XMVectorMultiplyAdd(C0, NormalAxis, V0);
|
|
R2 = XMVectorNegativeMultiplySubtract(C0, NormalAxis, V0);
|
|
|
|
V0 = XMVectorSelect(A, R0, g_XMSelect1110.v);
|
|
V1 = XMVectorPermute(R1, R2, Permute0Z1Y1Z0X.v);
|
|
V2 = XMVectorPermute(R1, R2, Permute0Y1X0Y1X.v);
|
|
|
|
M.r[0] = XMVectorPermute(V0, V1, Permute0X1X1Y0W.v);
|
|
M.r[1] = XMVectorPermute(V0, V1, Permute1Z0Y1W0W.v);
|
|
M.r[2] = XMVectorPermute(V0, V2, Permute1X1Y0Z0W.v);
|
|
M.r[3] = g_XMIdentityR3.v;
|
|
|
|
return M;
|
|
|
|
#elif defined(_XM_SSE_INTRINSICS_)
|
|
XMVECTOR N0, N1;
|
|
XMVECTOR V0, V1, V2;
|
|
XMVECTOR R0, R1, R2;
|
|
XMVECTOR C0, C1, C2;
|
|
XMMATRIX M;
|
|
|
|
FLOAT fSinAngle = sinf(Angle);
|
|
FLOAT fCosAngle = cosf(Angle);
|
|
|
|
C2 = _mm_set_ps1(1.0f - fCosAngle);
|
|
C1 = _mm_set_ps1(fCosAngle);
|
|
C0 = _mm_set_ps1(fSinAngle);
|
|
|
|
N0 = _mm_shuffle_ps(NormalAxis,NormalAxis,_MM_SHUFFLE(3,0,2,1));
|
|
// N0 = XMVectorPermute(NormalAxis, NormalAxis, SwizzleYZXW);
|
|
N1 = _mm_shuffle_ps(NormalAxis,NormalAxis,_MM_SHUFFLE(3,1,0,2));
|
|
// N1 = XMVectorPermute(NormalAxis, NormalAxis, SwizzleZXYW);
|
|
|
|
V0 = _mm_mul_ps(C2, N0);
|
|
V0 = _mm_mul_ps(V0, N1);
|
|
|
|
R0 = _mm_mul_ps(C2, NormalAxis);
|
|
R0 = _mm_mul_ps(R0, NormalAxis);
|
|
R0 = _mm_add_ps(R0, C1);
|
|
|
|
R1 = _mm_mul_ps(C0, NormalAxis);
|
|
R1 = _mm_add_ps(R1, V0);
|
|
R2 = _mm_mul_ps(C0, NormalAxis);
|
|
R2 = _mm_sub_ps(V0,R2);
|
|
|
|
V0 = _mm_and_ps(R0,g_XMMask3);
|
|
// V0 = XMVectorSelect(A, R0, g_XMSelect1110);
|
|
V1 = _mm_shuffle_ps(R1,R2,_MM_SHUFFLE(2,1,2,0));
|
|
V1 = _mm_shuffle_ps(V1,V1,_MM_SHUFFLE(0,3,2,1));
|
|
// V1 = XMVectorPermute(R1, R2, Permute0Z1Y1Z0X);
|
|
V2 = _mm_shuffle_ps(R1,R2,_MM_SHUFFLE(0,0,1,1));
|
|
V2 = _mm_shuffle_ps(V2,V2,_MM_SHUFFLE(2,0,2,0));
|
|
// V2 = XMVectorPermute(R1, R2, Permute0Y1X0Y1X);
|
|
|
|
R2 = _mm_shuffle_ps(V0,V1,_MM_SHUFFLE(1,0,3,0));
|
|
R2 = _mm_shuffle_ps(R2,R2,_MM_SHUFFLE(1,3,2,0));
|
|
M.r[0] = R2;
|
|
// M.r[0] = XMVectorPermute(V0, V1, Permute0X1X1Y0W);
|
|
R2 = _mm_shuffle_ps(V0,V1,_MM_SHUFFLE(3,2,3,1));
|
|
R2 = _mm_shuffle_ps(R2,R2,_MM_SHUFFLE(1,3,0,2));
|
|
M.r[1] = R2;
|
|
// M.r[1] = XMVectorPermute(V0, V1, Permute1Z0Y1W0W);
|
|
V2 = _mm_shuffle_ps(V2,V0,_MM_SHUFFLE(3,2,1,0));
|
|
// R2 = _mm_shuffle_ps(R2,R2,_MM_SHUFFLE(3,2,1,0));
|
|
M.r[2] = V2;
|
|
// M.r[2] = XMVectorPermute(V0, V2, Permute1X1Y0Z0W);
|
|
M.r[3] = g_XMIdentityR3;
|
|
return M;
|
|
#else // _XM_VMX128_INTRINSICS_
|
|
#endif // _XM_VMX128_INTRINSICS_
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
XMINLINE XMMATRIX XMMatrixRotationAxis
|
|
(
|
|
FXMVECTOR Axis,
|
|
FLOAT Angle
|
|
)
|
|
{
|
|
#if defined(_XM_NO_INTRINSICS_)
|
|
|
|
XMVECTOR Normal;
|
|
XMMATRIX M;
|
|
|
|
XMASSERT(!XMVector3Equal(Axis, XMVectorZero()));
|
|
XMASSERT(!XMVector3IsInfinite(Axis));
|
|
|
|
Normal = XMVector3Normalize(Axis);
|
|
M = XMMatrixRotationNormal(Normal, Angle);
|
|
|
|
return M;
|
|
|
|
#elif defined(_XM_SSE_INTRINSICS_)
|
|
XMASSERT(!XMVector3Equal(Axis, XMVectorZero()));
|
|
XMASSERT(!XMVector3IsInfinite(Axis));
|
|
XMVECTOR Normal = XMVector3Normalize(Axis);
|
|
XMMATRIX M = XMMatrixRotationNormal(Normal, Angle);
|
|
return M;
|
|
#else // _XM_VMX128_INTRINSICS_
|
|
#endif // _XM_VMX128_INTRINSICS_
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
XMFINLINE XMMATRIX XMMatrixRotationQuaternion
|
|
(
|
|
FXMVECTOR Quaternion
|
|
)
|
|
{
|
|
#if defined(_XM_NO_INTRINSICS_)
|
|
|
|
XMMATRIX M;
|
|
XMVECTOR Q0, Q1;
|
|
XMVECTOR V0, V1, V2;
|
|
XMVECTOR R0, R1, R2;
|
|
static CONST XMVECTOR Constant1110 = {1.0f, 1.0f, 1.0f, 0.0f};
|
|
static CONST XMVECTORU32 SwizzleXXYW = {XM_PERMUTE_0X, XM_PERMUTE_0X, XM_PERMUTE_0Y, XM_PERMUTE_0W};
|
|
static CONST XMVECTORU32 SwizzleZYZW = {XM_PERMUTE_0Z, XM_PERMUTE_0Y, XM_PERMUTE_0Z, XM_PERMUTE_0W};
|
|
static CONST XMVECTORU32 SwizzleYZXW = {XM_PERMUTE_0Y, XM_PERMUTE_0Z, XM_PERMUTE_0X, XM_PERMUTE_0W};
|
|
static CONST XMVECTORU32 Permute0Y0X0X1W = {XM_PERMUTE_0Y, XM_PERMUTE_0X, XM_PERMUTE_0X, XM_PERMUTE_1W};
|
|
static CONST XMVECTORU32 Permute0Z0Z0Y1W = {XM_PERMUTE_0Z, XM_PERMUTE_0Z, XM_PERMUTE_0Y, XM_PERMUTE_1W};
|
|
static CONST XMVECTORU32 Permute0Y1X1Y0Z = {XM_PERMUTE_0Y, XM_PERMUTE_1X, XM_PERMUTE_1Y, XM_PERMUTE_0Z};
|
|
static CONST XMVECTORU32 Permute0X1Z0X1Z = {XM_PERMUTE_0X, XM_PERMUTE_1Z, XM_PERMUTE_0X, XM_PERMUTE_1Z};
|
|
static CONST XMVECTORU32 Permute0X1X1Y0W = {XM_PERMUTE_0X, XM_PERMUTE_1X, XM_PERMUTE_1Y, XM_PERMUTE_0W};
|
|
static CONST XMVECTORU32 Permute1Z0Y1W0W = {XM_PERMUTE_1Z, XM_PERMUTE_0Y, XM_PERMUTE_1W, XM_PERMUTE_0W};
|
|
static CONST XMVECTORU32 Permute1X1Y0Z0W = {XM_PERMUTE_1X, XM_PERMUTE_1Y, XM_PERMUTE_0Z, XM_PERMUTE_0W};
|
|
|
|
Q0 = XMVectorAdd(Quaternion, Quaternion);
|
|
Q1 = XMVectorMultiply(Quaternion, Q0);
|
|
|
|
V0 = XMVectorPermute(Q1, Constant1110, Permute0Y0X0X1W.v);
|
|
V1 = XMVectorPermute(Q1, Constant1110, Permute0Z0Z0Y1W.v);
|
|
R0 = XMVectorSubtract(Constant1110, V0);
|
|
R0 = XMVectorSubtract(R0, V1);
|
|
|
|
V0 = XMVectorPermute(Quaternion, Quaternion, SwizzleXXYW.v);
|
|
V1 = XMVectorPermute(Q0, Q0, SwizzleZYZW.v);
|
|
V0 = XMVectorMultiply(V0, V1);
|
|
|
|
V1 = XMVectorSplatW(Quaternion);
|
|
V2 = XMVectorPermute(Q0, Q0, SwizzleYZXW.v);
|
|
V1 = XMVectorMultiply(V1, V2);
|
|
|
|
R1 = XMVectorAdd(V0, V1);
|
|
R2 = XMVectorSubtract(V0, V1);
|
|
|
|
V0 = XMVectorPermute(R1, R2, Permute0Y1X1Y0Z.v);
|
|
V1 = XMVectorPermute(R1, R2, Permute0X1Z0X1Z.v);
|
|
|
|
M.r[0] = XMVectorPermute(R0, V0, Permute0X1X1Y0W.v);
|
|
M.r[1] = XMVectorPermute(R0, V0, Permute1Z0Y1W0W.v);
|
|
M.r[2] = XMVectorPermute(R0, V1, Permute1X1Y0Z0W.v);
|
|
M.r[3] = g_XMIdentityR3.v;
|
|
|
|
return M;
|
|
|
|
#elif defined(_XM_SSE_INTRINSICS_)
|
|
XMMATRIX M;
|
|
XMVECTOR Q0, Q1;
|
|
XMVECTOR V0, V1, V2;
|
|
XMVECTOR R0, R1, R2;
|
|
static CONST XMVECTORF32 Constant1110 = {1.0f, 1.0f, 1.0f, 0.0f};
|
|
|
|
Q0 = _mm_add_ps(Quaternion,Quaternion);
|
|
Q1 = _mm_mul_ps(Quaternion,Q0);
|
|
|
|
V0 = _mm_shuffle_ps(Q1,Q1,_MM_SHUFFLE(3,0,0,1));
|
|
V0 = _mm_and_ps(V0,g_XMMask3);
|
|
// V0 = XMVectorPermute(Q1, Constant1110,Permute0Y0X0X1W);
|
|
V1 = _mm_shuffle_ps(Q1,Q1,_MM_SHUFFLE(3,1,2,2));
|
|
V1 = _mm_and_ps(V1,g_XMMask3);
|
|
// V1 = XMVectorPermute(Q1, Constant1110,Permute0Z0Z0Y1W);
|
|
R0 = _mm_sub_ps(Constant1110,V0);
|
|
R0 = _mm_sub_ps(R0, V1);
|
|
|
|
V0 = _mm_shuffle_ps(Quaternion,Quaternion,_MM_SHUFFLE(3,1,0,0));
|
|
// V0 = XMVectorPermute(Quaternion, Quaternion,SwizzleXXYW);
|
|
V1 = _mm_shuffle_ps(Q0,Q0,_MM_SHUFFLE(3,2,1,2));
|
|
// V1 = XMVectorPermute(Q0, Q0,SwizzleZYZW);
|
|
V0 = _mm_mul_ps(V0, V1);
|
|
|
|
V1 = _mm_shuffle_ps(Quaternion,Quaternion,_MM_SHUFFLE(3,3,3,3));
|
|
// V1 = XMVectorSplatW(Quaternion);
|
|
V2 = _mm_shuffle_ps(Q0,Q0,_MM_SHUFFLE(3,0,2,1));
|
|
// V2 = XMVectorPermute(Q0, Q0,SwizzleYZXW);
|
|
V1 = _mm_mul_ps(V1, V2);
|
|
|
|
R1 = _mm_add_ps(V0, V1);
|
|
R2 = _mm_sub_ps(V0, V1);
|
|
|
|
V0 = _mm_shuffle_ps(R1,R2,_MM_SHUFFLE(1,0,2,1));
|
|
V0 = _mm_shuffle_ps(V0,V0,_MM_SHUFFLE(1,3,2,0));
|
|
// V0 = XMVectorPermute(R1, R2,Permute0Y1X1Y0Z);
|
|
V1 = _mm_shuffle_ps(R1,R2,_MM_SHUFFLE(2,2,0,0));
|
|
V1 = _mm_shuffle_ps(V1,V1,_MM_SHUFFLE(2,0,2,0));
|
|
// V1 = XMVectorPermute(R1, R2,Permute0X1Z0X1Z);
|
|
|
|
Q1 = _mm_shuffle_ps(R0,V0,_MM_SHUFFLE(1,0,3,0));
|
|
Q1 = _mm_shuffle_ps(Q1,Q1,_MM_SHUFFLE(1,3,2,0));
|
|
M.r[0] = Q1;
|
|
// M.r[0] = XMVectorPermute(R0, V0,Permute0X1X1Y0W);
|
|
Q1 = _mm_shuffle_ps(R0,V0,_MM_SHUFFLE(3,2,3,1));
|
|
Q1 = _mm_shuffle_ps(Q1,Q1,_MM_SHUFFLE(1,3,0,2));
|
|
M.r[1] = Q1;
|
|
// M.r[1] = XMVectorPermute(R0, V0,Permute1Z0Y1W0W);
|
|
Q1 = _mm_shuffle_ps(V1,R0,_MM_SHUFFLE(3,2,1,0));
|
|
M.r[2] = Q1;
|
|
// M.r[2] = XMVectorPermute(R0, V1,Permute1X1Y0Z0W);
|
|
M.r[3] = g_XMIdentityR3;
|
|
return M;
|
|
#else // _XM_VMX128_INTRINSICS_
|
|
#endif // _XM_VMX128_INTRINSICS_
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
XMINLINE XMMATRIX XMMatrixTransformation2D
|
|
(
|
|
FXMVECTOR ScalingOrigin,
|
|
FLOAT ScalingOrientation,
|
|
FXMVECTOR Scaling,
|
|
FXMVECTOR RotationOrigin,
|
|
FLOAT Rotation,
|
|
CXMVECTOR Translation
|
|
)
|
|
{
|
|
#if defined(_XM_NO_INTRINSICS_)
|
|
|
|
XMMATRIX M;
|
|
XMVECTOR VScaling;
|
|
XMVECTOR NegScalingOrigin;
|
|
XMVECTOR VScalingOrigin;
|
|
XMMATRIX MScalingOriginI;
|
|
XMMATRIX MScalingOrientation;
|
|
XMMATRIX MScalingOrientationT;
|
|
XMMATRIX MScaling;
|
|
XMVECTOR VRotationOrigin;
|
|
XMMATRIX MRotation;
|
|
XMVECTOR VTranslation;
|
|
|
|
// M = Inverse(MScalingOrigin) * Transpose(MScalingOrientation) * MScaling * MScalingOrientation *
|
|
// MScalingOrigin * Inverse(MRotationOrigin) * MRotation * MRotationOrigin * MTranslation;
|
|
|
|
VScalingOrigin = XMVectorSelect(g_XMSelect1100.v, ScalingOrigin, g_XMSelect1100.v);
|
|
NegScalingOrigin = XMVectorNegate(VScalingOrigin);
|
|
|
|
MScalingOriginI = XMMatrixTranslationFromVector(NegScalingOrigin);
|
|
MScalingOrientation = XMMatrixRotationZ(ScalingOrientation);
|
|
MScalingOrientationT = XMMatrixTranspose(MScalingOrientation);
|
|
VScaling = XMVectorSelect(g_XMOne.v, Scaling, g_XMSelect1100.v);
|
|
MScaling = XMMatrixScalingFromVector(VScaling);
|
|
VRotationOrigin = XMVectorSelect(g_XMSelect1100.v, RotationOrigin, g_XMSelect1100.v);
|
|
MRotation = XMMatrixRotationZ(Rotation);
|
|
VTranslation = XMVectorSelect(g_XMSelect1100.v, Translation,g_XMSelect1100.v);
|
|
|
|
M = XMMatrixMultiply(MScalingOriginI, MScalingOrientationT);
|
|
M = XMMatrixMultiply(M, MScaling);
|
|
M = XMMatrixMultiply(M, MScalingOrientation);
|
|
M.r[3] = XMVectorAdd(M.r[3], VScalingOrigin);
|
|
M.r[3] = XMVectorSubtract(M.r[3], VRotationOrigin);
|
|
M = XMMatrixMultiply(M, MRotation);
|
|
M.r[3] = XMVectorAdd(M.r[3], VRotationOrigin);
|
|
M.r[3] = XMVectorAdd(M.r[3], VTranslation);
|
|
|
|
return M;
|
|
|
|
#elif defined(_XM_SSE_INTRINSICS_)
|
|
XMMATRIX M;
|
|
XMVECTOR VScaling;
|
|
XMVECTOR NegScalingOrigin;
|
|
XMVECTOR VScalingOrigin;
|
|
XMMATRIX MScalingOriginI;
|
|
XMMATRIX MScalingOrientation;
|
|
XMMATRIX MScalingOrientationT;
|
|
XMMATRIX MScaling;
|
|
XMVECTOR VRotationOrigin;
|
|
XMMATRIX MRotation;
|
|
XMVECTOR VTranslation;
|
|
|
|
// M = Inverse(MScalingOrigin) * Transpose(MScalingOrientation) * MScaling * MScalingOrientation *
|
|
// MScalingOrigin * Inverse(MRotationOrigin) * MRotation * MRotationOrigin * MTranslation;
|
|
static const XMVECTORU32 Mask2 = {0xFFFFFFFF,0xFFFFFFFF,0,0};
|
|
static const XMVECTORF32 ZWOne = {0,0,1.0f,1.0f};
|
|
|
|
VScalingOrigin = _mm_and_ps(ScalingOrigin, Mask2);
|
|
NegScalingOrigin = XMVectorNegate(VScalingOrigin);
|
|
|
|
MScalingOriginI = XMMatrixTranslationFromVector(NegScalingOrigin);
|
|
MScalingOrientation = XMMatrixRotationZ(ScalingOrientation);
|
|
MScalingOrientationT = XMMatrixTranspose(MScalingOrientation);
|
|
VScaling = _mm_and_ps(Scaling, Mask2);
|
|
VScaling = _mm_or_ps(VScaling,ZWOne);
|
|
MScaling = XMMatrixScalingFromVector(VScaling);
|
|
VRotationOrigin = _mm_and_ps(RotationOrigin, Mask2);
|
|
MRotation = XMMatrixRotationZ(Rotation);
|
|
VTranslation = _mm_and_ps(Translation, Mask2);
|
|
|
|
M = XMMatrixMultiply(MScalingOriginI, MScalingOrientationT);
|
|
M = XMMatrixMultiply(M, MScaling);
|
|
M = XMMatrixMultiply(M, MScalingOrientation);
|
|
M.r[3] = XMVectorAdd(M.r[3], VScalingOrigin);
|
|
M.r[3] = XMVectorSubtract(M.r[3], VRotationOrigin);
|
|
M = XMMatrixMultiply(M, MRotation);
|
|
M.r[3] = XMVectorAdd(M.r[3], VRotationOrigin);
|
|
M.r[3] = XMVectorAdd(M.r[3], VTranslation);
|
|
|
|
return M;
|
|
#else // _XM_VMX128_INTRINSICS_
|
|
#endif // _XM_VMX128_INTRINSICS_
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
XMINLINE XMMATRIX XMMatrixTransformation
|
|
(
|
|
FXMVECTOR ScalingOrigin,
|
|
FXMVECTOR ScalingOrientationQuaternion,
|
|
FXMVECTOR Scaling,
|
|
CXMVECTOR RotationOrigin,
|
|
CXMVECTOR RotationQuaternion,
|
|
CXMVECTOR Translation
|
|
)
|
|
{
|
|
#if defined(_XM_NO_INTRINSICS_)
|
|
|
|
XMMATRIX M;
|
|
XMVECTOR NegScalingOrigin;
|
|
XMVECTOR VScalingOrigin;
|
|
XMMATRIX MScalingOriginI;
|
|
XMMATRIX MScalingOrientation;
|
|
XMMATRIX MScalingOrientationT;
|
|
XMMATRIX MScaling;
|
|
XMVECTOR VRotationOrigin;
|
|
XMMATRIX MRotation;
|
|
XMVECTOR VTranslation;
|
|
|
|
// M = Inverse(MScalingOrigin) * Transpose(MScalingOrientation) * MScaling * MScalingOrientation *
|
|
// MScalingOrigin * Inverse(MRotationOrigin) * MRotation * MRotationOrigin * MTranslation;
|
|
|
|
VScalingOrigin = XMVectorSelect(g_XMSelect1110.v, ScalingOrigin, g_XMSelect1110.v);
|
|
NegScalingOrigin = XMVectorNegate(ScalingOrigin);
|
|
|
|
MScalingOriginI = XMMatrixTranslationFromVector(NegScalingOrigin);
|
|
MScalingOrientation = XMMatrixRotationQuaternion(ScalingOrientationQuaternion);
|
|
MScalingOrientationT = XMMatrixTranspose(MScalingOrientation);
|
|
MScaling = XMMatrixScalingFromVector(Scaling);
|
|
VRotationOrigin = XMVectorSelect(g_XMSelect1110.v, RotationOrigin, g_XMSelect1110.v);
|
|
MRotation = XMMatrixRotationQuaternion(RotationQuaternion);
|
|
VTranslation = XMVectorSelect(g_XMSelect1110.v, Translation, g_XMSelect1110.v);
|
|
|
|
M = XMMatrixMultiply(MScalingOriginI, MScalingOrientationT);
|
|
M = XMMatrixMultiply(M, MScaling);
|
|
M = XMMatrixMultiply(M, MScalingOrientation);
|
|
M.r[3] = XMVectorAdd(M.r[3], VScalingOrigin);
|
|
M.r[3] = XMVectorSubtract(M.r[3], VRotationOrigin);
|
|
M = XMMatrixMultiply(M, MRotation);
|
|
M.r[3] = XMVectorAdd(M.r[3], VRotationOrigin);
|
|
M.r[3] = XMVectorAdd(M.r[3], VTranslation);
|
|
|
|
return M;
|
|
|
|
#elif defined(_XM_SSE_INTRINSICS_)
|
|
XMMATRIX M;
|
|
XMVECTOR NegScalingOrigin;
|
|
XMVECTOR VScalingOrigin;
|
|
XMMATRIX MScalingOriginI;
|
|
XMMATRIX MScalingOrientation;
|
|
XMMATRIX MScalingOrientationT;
|
|
XMMATRIX MScaling;
|
|
XMVECTOR VRotationOrigin;
|
|
XMMATRIX MRotation;
|
|
XMVECTOR VTranslation;
|
|
|
|
// M = Inverse(MScalingOrigin) * Transpose(MScalingOrientation) * MScaling * MScalingOrientation *
|
|
// MScalingOrigin * Inverse(MRotationOrigin) * MRotation * MRotationOrigin * MTranslation;
|
|
|
|
VScalingOrigin = _mm_and_ps(ScalingOrigin,g_XMMask3);
|
|
NegScalingOrigin = XMVectorNegate(ScalingOrigin);
|
|
|
|
MScalingOriginI = XMMatrixTranslationFromVector(NegScalingOrigin);
|
|
MScalingOrientation = XMMatrixRotationQuaternion(ScalingOrientationQuaternion);
|
|
MScalingOrientationT = XMMatrixTranspose(MScalingOrientation);
|
|
MScaling = XMMatrixScalingFromVector(Scaling);
|
|
VRotationOrigin = _mm_and_ps(RotationOrigin,g_XMMask3);
|
|
MRotation = XMMatrixRotationQuaternion(RotationQuaternion);
|
|
VTranslation = _mm_and_ps(Translation,g_XMMask3);
|
|
|
|
M = XMMatrixMultiply(MScalingOriginI, MScalingOrientationT);
|
|
M = XMMatrixMultiply(M, MScaling);
|
|
M = XMMatrixMultiply(M, MScalingOrientation);
|
|
M.r[3] = XMVectorAdd(M.r[3], VScalingOrigin);
|
|
M.r[3] = XMVectorSubtract(M.r[3], VRotationOrigin);
|
|
M = XMMatrixMultiply(M, MRotation);
|
|
M.r[3] = XMVectorAdd(M.r[3], VRotationOrigin);
|
|
M.r[3] = XMVectorAdd(M.r[3], VTranslation);
|
|
|
|
return M;
|
|
#else // _XM_VMX128_INTRINSICS_
|
|
#endif // _XM_VMX128_INTRINSICS_
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
XMINLINE XMMATRIX XMMatrixAffineTransformation2D
|
|
(
|
|
FXMVECTOR Scaling,
|
|
FXMVECTOR RotationOrigin,
|
|
FLOAT Rotation,
|
|
FXMVECTOR Translation
|
|
)
|
|
{
|
|
#if defined(_XM_NO_INTRINSICS_)
|
|
|
|
XMMATRIX M;
|
|
XMVECTOR VScaling;
|
|
XMMATRIX MScaling;
|
|
XMVECTOR VRotationOrigin;
|
|
XMMATRIX MRotation;
|
|
XMVECTOR VTranslation;
|
|
|
|
// M = MScaling * Inverse(MRotationOrigin) * MRotation * MRotationOrigin * MTranslation;
|
|
|
|
VScaling = XMVectorSelect(g_XMOne.v, Scaling, g_XMSelect1100.v);
|
|
MScaling = XMMatrixScalingFromVector(VScaling);
|
|
VRotationOrigin = XMVectorSelect(g_XMSelect1100.v, RotationOrigin, g_XMSelect1100.v);
|
|
MRotation = XMMatrixRotationZ(Rotation);
|
|
VTranslation = XMVectorSelect(g_XMSelect1100.v, Translation,g_XMSelect1100.v);
|
|
|
|
M = MScaling;
|
|
M.r[3] = XMVectorSubtract(M.r[3], VRotationOrigin);
|
|
M = XMMatrixMultiply(M, MRotation);
|
|
M.r[3] = XMVectorAdd(M.r[3], VRotationOrigin);
|
|
M.r[3] = XMVectorAdd(M.r[3], VTranslation);
|
|
|
|
return M;
|
|
|
|
#elif defined(_XM_SSE_INTRINSICS_)
|
|
XMMATRIX M;
|
|
XMVECTOR VScaling;
|
|
XMMATRIX MScaling;
|
|
XMVECTOR VRotationOrigin;
|
|
XMMATRIX MRotation;
|
|
XMVECTOR VTranslation;
|
|
static const XMVECTORU32 Mask2 = {0xFFFFFFFFU,0xFFFFFFFFU,0,0};
|
|
static const XMVECTORF32 ZW1 = {0,0,1.0f,1.0f};
|
|
|
|
// M = MScaling * Inverse(MRotationOrigin) * MRotation * MRotationOrigin * MTranslation;
|
|
|
|
VScaling = _mm_and_ps(Scaling, Mask2);
|
|
VScaling = _mm_or_ps(VScaling, ZW1);
|
|
MScaling = XMMatrixScalingFromVector(VScaling);
|
|
VRotationOrigin = _mm_and_ps(RotationOrigin, Mask2);
|
|
MRotation = XMMatrixRotationZ(Rotation);
|
|
VTranslation = _mm_and_ps(Translation, Mask2);
|
|
|
|
M = MScaling;
|
|
M.r[3] = _mm_sub_ps(M.r[3], VRotationOrigin);
|
|
M = XMMatrixMultiply(M, MRotation);
|
|
M.r[3] = _mm_add_ps(M.r[3], VRotationOrigin);
|
|
M.r[3] = _mm_add_ps(M.r[3], VTranslation);
|
|
return M;
|
|
#else // _XM_VMX128_INTRINSICS_
|
|
#endif // _XM_VMX128_INTRINSICS_
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
XMINLINE XMMATRIX XMMatrixAffineTransformation
|
|
(
|
|
FXMVECTOR Scaling,
|
|
FXMVECTOR RotationOrigin,
|
|
FXMVECTOR RotationQuaternion,
|
|
CXMVECTOR Translation
|
|
)
|
|
{
|
|
#if defined(_XM_NO_INTRINSICS_)
|
|
|
|
XMMATRIX M;
|
|
XMMATRIX MScaling;
|
|
XMVECTOR VRotationOrigin;
|
|
XMMATRIX MRotation;
|
|
XMVECTOR VTranslation;
|
|
|
|
// M = MScaling * Inverse(MRotationOrigin) * MRotation * MRotationOrigin * MTranslation;
|
|
|
|
MScaling = XMMatrixScalingFromVector(Scaling);
|
|
VRotationOrigin = XMVectorSelect(g_XMSelect1110.v, RotationOrigin,g_XMSelect1110.v);
|
|
MRotation = XMMatrixRotationQuaternion(RotationQuaternion);
|
|
VTranslation = XMVectorSelect(g_XMSelect1110.v, Translation,g_XMSelect1110.v);
|
|
|
|
M = MScaling;
|
|
M.r[3] = XMVectorSubtract(M.r[3], VRotationOrigin);
|
|
M = XMMatrixMultiply(M, MRotation);
|
|
M.r[3] = XMVectorAdd(M.r[3], VRotationOrigin);
|
|
M.r[3] = XMVectorAdd(M.r[3], VTranslation);
|
|
|
|
return M;
|
|
|
|
#elif defined(_XM_SSE_INTRINSICS_)
|
|
XMMATRIX M;
|
|
XMMATRIX MScaling;
|
|
XMVECTOR VRotationOrigin;
|
|
XMMATRIX MRotation;
|
|
XMVECTOR VTranslation;
|
|
|
|
// M = MScaling * Inverse(MRotationOrigin) * MRotation * MRotationOrigin * MTranslation;
|
|
|
|
MScaling = XMMatrixScalingFromVector(Scaling);
|
|
VRotationOrigin = _mm_and_ps(RotationOrigin,g_XMMask3);
|
|
MRotation = XMMatrixRotationQuaternion(RotationQuaternion);
|
|
VTranslation = _mm_and_ps(Translation,g_XMMask3);
|
|
|
|
M = MScaling;
|
|
M.r[3] = _mm_sub_ps(M.r[3], VRotationOrigin);
|
|
M = XMMatrixMultiply(M, MRotation);
|
|
M.r[3] = _mm_add_ps(M.r[3], VRotationOrigin);
|
|
M.r[3] = _mm_add_ps(M.r[3], VTranslation);
|
|
|
|
return M;
|
|
#else // _XM_VMX128_INTRINSICS_
|
|
#endif // _XM_VMX128_INTRINSICS_
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
XMFINLINE XMMATRIX XMMatrixReflect
|
|
(
|
|
FXMVECTOR ReflectionPlane
|
|
)
|
|
{
|
|
#if defined(_XM_NO_INTRINSICS_)
|
|
|
|
XMVECTOR P;
|
|
XMVECTOR S;
|
|
XMVECTOR A, B, C, D;
|
|
XMMATRIX M;
|
|
static CONST XMVECTOR NegativeTwo = {-2.0f, -2.0f, -2.0f, 0.0f};
|
|
|
|
XMASSERT(!XMVector3Equal(ReflectionPlane, XMVectorZero()));
|
|
XMASSERT(!XMPlaneIsInfinite(ReflectionPlane));
|
|
|
|
P = XMPlaneNormalize(ReflectionPlane);
|
|
S = XMVectorMultiply(P, NegativeTwo);
|
|
|
|
A = XMVectorSplatX(P);
|
|
B = XMVectorSplatY(P);
|
|
C = XMVectorSplatZ(P);
|
|
D = XMVectorSplatW(P);
|
|
|
|
M.r[0] = XMVectorMultiplyAdd(A, S, g_XMIdentityR0.v);
|
|
M.r[1] = XMVectorMultiplyAdd(B, S, g_XMIdentityR1.v);
|
|
M.r[2] = XMVectorMultiplyAdd(C, S, g_XMIdentityR2.v);
|
|
M.r[3] = XMVectorMultiplyAdd(D, S, g_XMIdentityR3.v);
|
|
|
|
return M;
|
|
|
|
#elif defined(_XM_SSE_INTRINSICS_)
|
|
XMMATRIX M;
|
|
static CONST XMVECTORF32 NegativeTwo = {-2.0f, -2.0f, -2.0f, 0.0f};
|
|
|
|
XMASSERT(!XMVector3Equal(ReflectionPlane, XMVectorZero()));
|
|
XMASSERT(!XMPlaneIsInfinite(ReflectionPlane));
|
|
|
|
XMVECTOR P = XMPlaneNormalize(ReflectionPlane);
|
|
XMVECTOR S = _mm_mul_ps(P,NegativeTwo);
|
|
XMVECTOR X = _mm_shuffle_ps(P,P,_MM_SHUFFLE(0,0,0,0));
|
|
XMVECTOR Y = _mm_shuffle_ps(P,P,_MM_SHUFFLE(1,1,1,1));
|
|
XMVECTOR Z = _mm_shuffle_ps(P,P,_MM_SHUFFLE(2,2,2,2));
|
|
P = _mm_shuffle_ps(P,P,_MM_SHUFFLE(3,3,3,3));
|
|
X = _mm_mul_ps(X,S);
|
|
Y = _mm_mul_ps(Y,S);
|
|
Z = _mm_mul_ps(Z,S);
|
|
P = _mm_mul_ps(P,S);
|
|
X = _mm_add_ps(X,g_XMIdentityR0);
|
|
Y = _mm_add_ps(Y,g_XMIdentityR1);
|
|
Z = _mm_add_ps(Z,g_XMIdentityR2);
|
|
P = _mm_add_ps(P,g_XMIdentityR3);
|
|
M.r[0] = X;
|
|
M.r[1] = Y;
|
|
M.r[2] = Z;
|
|
M.r[3] = P;
|
|
return M;
|
|
#else // _XM_VMX128_INTRINSICS_
|
|
#endif // _XM_VMX128_INTRINSICS_
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
XMFINLINE XMMATRIX XMMatrixShadow
|
|
(
|
|
FXMVECTOR ShadowPlane,
|
|
FXMVECTOR LightPosition
|
|
)
|
|
{
|
|
#if defined(_XM_NO_INTRINSICS_)
|
|
|
|
XMVECTOR P;
|
|
XMVECTOR Dot;
|
|
XMVECTOR A, B, C, D;
|
|
XMMATRIX M;
|
|
static CONST XMVECTORU32 Select0001 = {XM_SELECT_0, XM_SELECT_0, XM_SELECT_0, XM_SELECT_1};
|
|
|
|
XMASSERT(!XMVector3Equal(ShadowPlane, XMVectorZero()));
|
|
XMASSERT(!XMPlaneIsInfinite(ShadowPlane));
|
|
|
|
P = XMPlaneNormalize(ShadowPlane);
|
|
Dot = XMPlaneDot(P, LightPosition);
|
|
P = XMVectorNegate(P);
|
|
D = XMVectorSplatW(P);
|
|
C = XMVectorSplatZ(P);
|
|
B = XMVectorSplatY(P);
|
|
A = XMVectorSplatX(P);
|
|
Dot = XMVectorSelect(Select0001.v, Dot, Select0001.v);
|
|
M.r[3] = XMVectorMultiplyAdd(D, LightPosition, Dot);
|
|
Dot = XMVectorRotateLeft(Dot, 1);
|
|
M.r[2] = XMVectorMultiplyAdd(C, LightPosition, Dot);
|
|
Dot = XMVectorRotateLeft(Dot, 1);
|
|
M.r[1] = XMVectorMultiplyAdd(B, LightPosition, Dot);
|
|
Dot = XMVectorRotateLeft(Dot, 1);
|
|
M.r[0] = XMVectorMultiplyAdd(A, LightPosition, Dot);
|
|
return M;
|
|
|
|
#elif defined(_XM_SSE_INTRINSICS_)
|
|
XMMATRIX M;
|
|
XMASSERT(!XMVector3Equal(ShadowPlane, XMVectorZero()));
|
|
XMASSERT(!XMPlaneIsInfinite(ShadowPlane));
|
|
XMVECTOR P = XMPlaneNormalize(ShadowPlane);
|
|
XMVECTOR Dot = XMPlaneDot(P,LightPosition);
|
|
// Negate
|
|
P = _mm_mul_ps(P,g_XMNegativeOne);
|
|
XMVECTOR X = _mm_shuffle_ps(P,P,_MM_SHUFFLE(0,0,0,0));
|
|
XMVECTOR Y = _mm_shuffle_ps(P,P,_MM_SHUFFLE(1,1,1,1));
|
|
XMVECTOR Z = _mm_shuffle_ps(P,P,_MM_SHUFFLE(2,2,2,2));
|
|
P = _mm_shuffle_ps(P,P,_MM_SHUFFLE(3,3,3,3));
|
|
Dot = _mm_and_ps(Dot,g_XMMaskW);
|
|
X = _mm_mul_ps(X,LightPosition);
|
|
Y = _mm_mul_ps(Y,LightPosition);
|
|
Z = _mm_mul_ps(Z,LightPosition);
|
|
P = _mm_mul_ps(P,LightPosition);
|
|
P = _mm_add_ps(P,Dot);
|
|
Dot = _mm_shuffle_ps(Dot,Dot,_MM_SHUFFLE(0,3,2,1));
|
|
Z = _mm_add_ps(Z,Dot);
|
|
Dot = _mm_shuffle_ps(Dot,Dot,_MM_SHUFFLE(0,3,2,1));
|
|
Y = _mm_add_ps(Y,Dot);
|
|
Dot = _mm_shuffle_ps(Dot,Dot,_MM_SHUFFLE(0,3,2,1));
|
|
X = _mm_add_ps(X,Dot);
|
|
// Store the resulting matrix
|
|
M.r[0] = X;
|
|
M.r[1] = Y;
|
|
M.r[2] = Z;
|
|
M.r[3] = P;
|
|
return M;
|
|
#else // _XM_VMX128_INTRINSICS_
|
|
#endif // _XM_VMX128_INTRINSICS_
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// View and projection initialization operations
|
|
//------------------------------------------------------------------------------
|
|
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
XMFINLINE XMMATRIX XMMatrixLookAtLH
|
|
(
|
|
FXMVECTOR EyePosition,
|
|
FXMVECTOR FocusPosition,
|
|
FXMVECTOR UpDirection
|
|
)
|
|
{
|
|
XMVECTOR EyeDirection;
|
|
XMMATRIX M;
|
|
|
|
EyeDirection = XMVectorSubtract(FocusPosition, EyePosition);
|
|
M = XMMatrixLookToLH(EyePosition, EyeDirection, UpDirection);
|
|
|
|
return M;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
XMFINLINE XMMATRIX XMMatrixLookAtRH
|
|
(
|
|
FXMVECTOR EyePosition,
|
|
FXMVECTOR FocusPosition,
|
|
FXMVECTOR UpDirection
|
|
)
|
|
{
|
|
XMVECTOR NegEyeDirection;
|
|
XMMATRIX M;
|
|
|
|
NegEyeDirection = XMVectorSubtract(EyePosition, FocusPosition);
|
|
M = XMMatrixLookToLH(EyePosition, NegEyeDirection, UpDirection);
|
|
|
|
return M;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
XMINLINE XMMATRIX XMMatrixLookToLH
|
|
(
|
|
FXMVECTOR EyePosition,
|
|
FXMVECTOR EyeDirection,
|
|
FXMVECTOR UpDirection
|
|
)
|
|
{
|
|
#if defined(_XM_NO_INTRINSICS_)
|
|
|
|
XMVECTOR NegEyePosition;
|
|
XMVECTOR D0, D1, D2;
|
|
XMVECTOR R0, R1, R2;
|
|
XMMATRIX M;
|
|
|
|
XMASSERT(!XMVector3Equal(EyeDirection, XMVectorZero()));
|
|
XMASSERT(!XMVector3IsInfinite(EyeDirection));
|
|
XMASSERT(!XMVector3Equal(UpDirection, XMVectorZero()));
|
|
XMASSERT(!XMVector3IsInfinite(UpDirection));
|
|
|
|
R2 = XMVector3Normalize(EyeDirection);
|
|
|
|
R0 = XMVector3Cross(UpDirection, R2);
|
|
R0 = XMVector3Normalize(R0);
|
|
|
|
R1 = XMVector3Cross(R2, R0);
|
|
|
|
NegEyePosition = XMVectorNegate(EyePosition);
|
|
|
|
D0 = XMVector3Dot(R0, NegEyePosition);
|
|
D1 = XMVector3Dot(R1, NegEyePosition);
|
|
D2 = XMVector3Dot(R2, NegEyePosition);
|
|
|
|
M.r[0] = XMVectorSelect(D0, R0, g_XMSelect1110.v);
|
|
M.r[1] = XMVectorSelect(D1, R1, g_XMSelect1110.v);
|
|
M.r[2] = XMVectorSelect(D2, R2, g_XMSelect1110.v);
|
|
M.r[3] = g_XMIdentityR3.v;
|
|
|
|
M = XMMatrixTranspose(M);
|
|
|
|
return M;
|
|
|
|
#elif defined(_XM_SSE_INTRINSICS_)
|
|
XMMATRIX M;
|
|
|
|
XMASSERT(!XMVector3Equal(EyeDirection, XMVectorZero()));
|
|
XMASSERT(!XMVector3IsInfinite(EyeDirection));
|
|
XMASSERT(!XMVector3Equal(UpDirection, XMVectorZero()));
|
|
XMASSERT(!XMVector3IsInfinite(UpDirection));
|
|
|
|
XMVECTOR R2 = XMVector3Normalize(EyeDirection);
|
|
XMVECTOR R0 = XMVector3Cross(UpDirection, R2);
|
|
R0 = XMVector3Normalize(R0);
|
|
XMVECTOR R1 = XMVector3Cross(R2,R0);
|
|
XMVECTOR NegEyePosition = _mm_mul_ps(EyePosition,g_XMNegativeOne);
|
|
XMVECTOR D0 = XMVector3Dot(R0,NegEyePosition);
|
|
XMVECTOR D1 = XMVector3Dot(R1,NegEyePosition);
|
|
XMVECTOR D2 = XMVector3Dot(R2,NegEyePosition);
|
|
R0 = _mm_and_ps(R0,g_XMMask3);
|
|
R1 = _mm_and_ps(R1,g_XMMask3);
|
|
R2 = _mm_and_ps(R2,g_XMMask3);
|
|
D0 = _mm_and_ps(D0,g_XMMaskW);
|
|
D1 = _mm_and_ps(D1,g_XMMaskW);
|
|
D2 = _mm_and_ps(D2,g_XMMaskW);
|
|
D0 = _mm_or_ps(D0,R0);
|
|
D1 = _mm_or_ps(D1,R1);
|
|
D2 = _mm_or_ps(D2,R2);
|
|
M.r[0] = D0;
|
|
M.r[1] = D1;
|
|
M.r[2] = D2;
|
|
M.r[3] = g_XMIdentityR3;
|
|
M = XMMatrixTranspose(M);
|
|
return M;
|
|
#else // _XM_VMX128_INTRINSICS_
|
|
#endif // _XM_VMX128_INTRINSICS_
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
XMFINLINE XMMATRIX XMMatrixLookToRH
|
|
(
|
|
FXMVECTOR EyePosition,
|
|
FXMVECTOR EyeDirection,
|
|
FXMVECTOR UpDirection
|
|
)
|
|
{
|
|
XMVECTOR NegEyeDirection;
|
|
XMMATRIX M;
|
|
|
|
NegEyeDirection = XMVectorNegate(EyeDirection);
|
|
M = XMMatrixLookToLH(EyePosition, NegEyeDirection, UpDirection);
|
|
|
|
return M;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
XMFINLINE XMMATRIX XMMatrixPerspectiveLH
|
|
(
|
|
FLOAT ViewWidth,
|
|
FLOAT ViewHeight,
|
|
FLOAT NearZ,
|
|
FLOAT FarZ
|
|
)
|
|
{
|
|
#if defined(_XM_NO_INTRINSICS_)
|
|
|
|
FLOAT TwoNearZ, fRange;
|
|
XMMATRIX M;
|
|
|
|
XMASSERT(!XMScalarNearEqual(ViewWidth, 0.0f, 0.00001f));
|
|
XMASSERT(!XMScalarNearEqual(ViewHeight, 0.0f, 0.00001f));
|
|
XMASSERT(!XMScalarNearEqual(FarZ, NearZ, 0.00001f));
|
|
|
|
TwoNearZ = NearZ + NearZ;
|
|
fRange = FarZ / (FarZ - NearZ);
|
|
M.m[0][0] = TwoNearZ / ViewWidth;
|
|
M.m[0][1] = 0.0f;
|
|
M.m[0][2] = 0.0f;
|
|
M.m[0][3] = 0.0f;
|
|
|
|
M.m[1][0] = 0.0f;
|
|
M.m[1][1] = TwoNearZ / ViewHeight;
|
|
M.m[1][2] = 0.0f;
|
|
M.m[1][3] = 0.0f;
|
|
|
|
M.m[2][0] = 0.0f;
|
|
M.m[2][1] = 0.0f;
|
|
M.m[2][2] = fRange;
|
|
M.m[2][3] = 1.0f;
|
|
|
|
M.m[3][0] = 0.0f;
|
|
M.m[3][1] = 0.0f;
|
|
M.m[3][2] = -fRange * NearZ;
|
|
M.m[3][3] = 0.0f;
|
|
|
|
return M;
|
|
|
|
#elif defined(_XM_SSE_INTRINSICS_)
|
|
XMASSERT(!XMScalarNearEqual(ViewWidth, 0.0f, 0.00001f));
|
|
XMASSERT(!XMScalarNearEqual(ViewHeight, 0.0f, 0.00001f));
|
|
XMASSERT(!XMScalarNearEqual(FarZ, NearZ, 0.00001f));
|
|
|
|
XMMATRIX M;
|
|
FLOAT TwoNearZ = NearZ + NearZ;
|
|
FLOAT fRange = FarZ / (FarZ - NearZ);
|
|
// Note: This is recorded on the stack
|
|
XMVECTOR rMem = {
|
|
TwoNearZ / ViewWidth,
|
|
TwoNearZ / ViewHeight,
|
|
fRange,
|
|
-fRange * NearZ
|
|
};
|
|
// Copy from memory to SSE register
|
|
XMVECTOR vValues = rMem;
|
|
XMVECTOR vTemp = _mm_setzero_ps();
|
|
// Copy x only
|
|
vTemp = _mm_move_ss(vTemp,vValues);
|
|
// TwoNearZ / ViewWidth,0,0,0
|
|
M.r[0] = vTemp;
|
|
// 0,TwoNearZ / ViewHeight,0,0
|
|
vTemp = vValues;
|
|
vTemp = _mm_and_ps(vTemp,g_XMMaskY);
|
|
M.r[1] = vTemp;
|
|
// x=fRange,y=-fRange * NearZ,0,1.0f
|
|
vValues = _mm_shuffle_ps(vValues,g_XMIdentityR3,_MM_SHUFFLE(3,2,3,2));
|
|
// 0,0,fRange,1.0f
|
|
vTemp = _mm_setzero_ps();
|
|
vTemp = _mm_shuffle_ps(vTemp,vValues,_MM_SHUFFLE(3,0,0,0));
|
|
M.r[2] = vTemp;
|
|
// 0,0,-fRange * NearZ,0
|
|
vTemp = _mm_shuffle_ps(vTemp,vValues,_MM_SHUFFLE(2,1,0,0));
|
|
M.r[3] = vTemp;
|
|
|
|
return M;
|
|
#else // _XM_VMX128_INTRINSICS_
|
|
#endif // _XM_VMX128_INTRINSICS_
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
XMFINLINE XMMATRIX XMMatrixPerspectiveRH
|
|
(
|
|
FLOAT ViewWidth,
|
|
FLOAT ViewHeight,
|
|
FLOAT NearZ,
|
|
FLOAT FarZ
|
|
)
|
|
{
|
|
#if defined(_XM_NO_INTRINSICS_)
|
|
|
|
FLOAT TwoNearZ, fRange;
|
|
XMMATRIX M;
|
|
|
|
XMASSERT(!XMScalarNearEqual(ViewWidth, 0.0f, 0.00001f));
|
|
XMASSERT(!XMScalarNearEqual(ViewHeight, 0.0f, 0.00001f));
|
|
XMASSERT(!XMScalarNearEqual(FarZ, NearZ, 0.00001f));
|
|
|
|
TwoNearZ = NearZ + NearZ;
|
|
fRange = FarZ / (NearZ - FarZ);
|
|
M.m[0][0] = TwoNearZ / ViewWidth;
|
|
M.m[0][1] = 0.0f;
|
|
M.m[0][2] = 0.0f;
|
|
M.m[0][3] = 0.0f;
|
|
|
|
M.m[1][0] = 0.0f;
|
|
M.m[1][1] = TwoNearZ / ViewHeight;
|
|
M.m[1][2] = 0.0f;
|
|
M.m[1][3] = 0.0f;
|
|
|
|
M.m[2][0] = 0.0f;
|
|
M.m[2][1] = 0.0f;
|
|
M.m[2][2] = fRange;
|
|
M.m[2][3] = -1.0f;
|
|
|
|
M.m[3][0] = 0.0f;
|
|
M.m[3][1] = 0.0f;
|
|
M.m[3][2] = fRange * NearZ;
|
|
M.m[3][3] = 0.0f;
|
|
|
|
return M;
|
|
|
|
#elif defined(_XM_SSE_INTRINSICS_)
|
|
XMASSERT(!XMScalarNearEqual(ViewWidth, 0.0f, 0.00001f));
|
|
XMASSERT(!XMScalarNearEqual(ViewHeight, 0.0f, 0.00001f));
|
|
XMASSERT(!XMScalarNearEqual(FarZ, NearZ, 0.00001f));
|
|
|
|
XMMATRIX M;
|
|
FLOAT TwoNearZ = NearZ + NearZ;
|
|
FLOAT fRange = FarZ / (NearZ-FarZ);
|
|
// Note: This is recorded on the stack
|
|
XMVECTOR rMem = {
|
|
TwoNearZ / ViewWidth,
|
|
TwoNearZ / ViewHeight,
|
|
fRange,
|
|
fRange * NearZ
|
|
};
|
|
// Copy from memory to SSE register
|
|
XMVECTOR vValues = rMem;
|
|
XMVECTOR vTemp = _mm_setzero_ps();
|
|
// Copy x only
|
|
vTemp = _mm_move_ss(vTemp,vValues);
|
|
// TwoNearZ / ViewWidth,0,0,0
|
|
M.r[0] = vTemp;
|
|
// 0,TwoNearZ / ViewHeight,0,0
|
|
vTemp = vValues;
|
|
vTemp = _mm_and_ps(vTemp,g_XMMaskY);
|
|
M.r[1] = vTemp;
|
|
// x=fRange,y=-fRange * NearZ,0,-1.0f
|
|
vValues = _mm_shuffle_ps(vValues,g_XMNegIdentityR3,_MM_SHUFFLE(3,2,3,2));
|
|
// 0,0,fRange,-1.0f
|
|
vTemp = _mm_setzero_ps();
|
|
vTemp = _mm_shuffle_ps(vTemp,vValues,_MM_SHUFFLE(3,0,0,0));
|
|
M.r[2] = vTemp;
|
|
// 0,0,-fRange * NearZ,0
|
|
vTemp = _mm_shuffle_ps(vTemp,vValues,_MM_SHUFFLE(2,1,0,0));
|
|
M.r[3] = vTemp;
|
|
return M;
|
|
#else // _XM_VMX128_INTRINSICS_
|
|
#endif // _XM_VMX128_INTRINSICS_
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
XMFINLINE XMMATRIX XMMatrixPerspectiveFovLH
|
|
(
|
|
FLOAT FovAngleY,
|
|
FLOAT AspectRatio,
|
|
FLOAT NearZ,
|
|
FLOAT FarZ
|
|
)
|
|
{
|
|
#if defined(_XM_NO_INTRINSICS_)
|
|
|
|
FLOAT SinFov;
|
|
FLOAT CosFov;
|
|
FLOAT Height;
|
|
FLOAT Width;
|
|
XMMATRIX M;
|
|
|
|
XMASSERT(!XMScalarNearEqual(FovAngleY, 0.0f, 0.00001f * 2.0f));
|
|
XMASSERT(!XMScalarNearEqual(AspectRatio, 0.0f, 0.00001f));
|
|
XMASSERT(!XMScalarNearEqual(FarZ, NearZ, 0.00001f));
|
|
|
|
XMScalarSinCos(&SinFov, &CosFov, 0.5f * FovAngleY);
|
|
|
|
Height = CosFov / SinFov;
|
|
Width = Height / AspectRatio;
|
|
|
|
M.r[0] = XMVectorSet(Width, 0.0f, 0.0f, 0.0f);
|
|
M.r[1] = XMVectorSet(0.0f, Height, 0.0f, 0.0f);
|
|
M.r[2] = XMVectorSet(0.0f, 0.0f, FarZ / (FarZ - NearZ), 1.0f);
|
|
M.r[3] = XMVectorSet(0.0f, 0.0f, -M.r[2].vector4_f32[2] * NearZ, 0.0f);
|
|
|
|
return M;
|
|
|
|
#elif defined(_XM_SSE_INTRINSICS_)
|
|
XMASSERT(!XMScalarNearEqual(FovAngleY, 0.0f, 0.00001f * 2.0f));
|
|
XMASSERT(!XMScalarNearEqual(AspectRatio, 0.0f, 0.00001f));
|
|
XMASSERT(!XMScalarNearEqual(FarZ, NearZ, 0.00001f));
|
|
XMMATRIX M;
|
|
FLOAT SinFov;
|
|
FLOAT CosFov;
|
|
XMScalarSinCos(&SinFov, &CosFov, 0.5f * FovAngleY);
|
|
FLOAT fRange = FarZ / (FarZ-NearZ);
|
|
// Note: This is recorded on the stack
|
|
FLOAT Height = CosFov / SinFov;
|
|
XMVECTOR rMem = {
|
|
Height / AspectRatio,
|
|
Height,
|
|
fRange,
|
|
-fRange * NearZ
|
|
};
|
|
// Copy from memory to SSE register
|
|
XMVECTOR vValues = rMem;
|
|
XMVECTOR vTemp = _mm_setzero_ps();
|
|
// Copy x only
|
|
vTemp = _mm_move_ss(vTemp,vValues);
|
|
// CosFov / SinFov,0,0,0
|
|
M.r[0] = vTemp;
|
|
// 0,Height / AspectRatio,0,0
|
|
vTemp = vValues;
|
|
vTemp = _mm_and_ps(vTemp,g_XMMaskY);
|
|
M.r[1] = vTemp;
|
|
// x=fRange,y=-fRange * NearZ,0,1.0f
|
|
vTemp = _mm_setzero_ps();
|
|
vValues = _mm_shuffle_ps(vValues,g_XMIdentityR3,_MM_SHUFFLE(3,2,3,2));
|
|
// 0,0,fRange,1.0f
|
|
vTemp = _mm_shuffle_ps(vTemp,vValues,_MM_SHUFFLE(3,0,0,0));
|
|
M.r[2] = vTemp;
|
|
// 0,0,-fRange * NearZ,0.0f
|
|
vTemp = _mm_shuffle_ps(vTemp,vValues,_MM_SHUFFLE(2,1,0,0));
|
|
M.r[3] = vTemp;
|
|
return M;
|
|
#else // _XM_VMX128_INTRINSICS_
|
|
#endif // _XM_VMX128_INTRINSICS_
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
XMFINLINE XMMATRIX XMMatrixPerspectiveFovRH
|
|
(
|
|
FLOAT FovAngleY,
|
|
FLOAT AspectRatio,
|
|
FLOAT NearZ,
|
|
FLOAT FarZ
|
|
)
|
|
{
|
|
#if defined(_XM_NO_INTRINSICS_)
|
|
|
|
FLOAT SinFov;
|
|
FLOAT CosFov;
|
|
FLOAT Height;
|
|
FLOAT Width;
|
|
XMMATRIX M;
|
|
|
|
XMASSERT(!XMScalarNearEqual(FovAngleY, 0.0f, 0.00001f * 2.0f));
|
|
XMASSERT(!XMScalarNearEqual(AspectRatio, 0.0f, 0.00001f));
|
|
XMASSERT(!XMScalarNearEqual(FarZ, NearZ, 0.00001f));
|
|
|
|
XMScalarSinCos(&SinFov, &CosFov, 0.5f * FovAngleY);
|
|
|
|
Height = CosFov / SinFov;
|
|
Width = Height / AspectRatio;
|
|
|
|
M.r[0] = XMVectorSet(Width, 0.0f, 0.0f, 0.0f);
|
|
M.r[1] = XMVectorSet(0.0f, Height, 0.0f, 0.0f);
|
|
M.r[2] = XMVectorSet(0.0f, 0.0f, FarZ / (NearZ - FarZ), -1.0f);
|
|
M.r[3] = XMVectorSet(0.0f, 0.0f, M.r[2].vector4_f32[2] * NearZ, 0.0f);
|
|
|
|
return M;
|
|
|
|
#elif defined(_XM_SSE_INTRINSICS_)
|
|
XMASSERT(!XMScalarNearEqual(FovAngleY, 0.0f, 0.00001f * 2.0f));
|
|
XMASSERT(!XMScalarNearEqual(AspectRatio, 0.0f, 0.00001f));
|
|
XMASSERT(!XMScalarNearEqual(FarZ, NearZ, 0.00001f));
|
|
XMMATRIX M;
|
|
FLOAT SinFov;
|
|
FLOAT CosFov;
|
|
XMScalarSinCos(&SinFov, &CosFov, 0.5f * FovAngleY);
|
|
FLOAT fRange = FarZ / (NearZ-FarZ);
|
|
// Note: This is recorded on the stack
|
|
FLOAT Height = CosFov / SinFov;
|
|
XMVECTOR rMem = {
|
|
Height / AspectRatio,
|
|
Height,
|
|
fRange,
|
|
fRange * NearZ
|
|
};
|
|
// Copy from memory to SSE register
|
|
XMVECTOR vValues = rMem;
|
|
XMVECTOR vTemp = _mm_setzero_ps();
|
|
// Copy x only
|
|
vTemp = _mm_move_ss(vTemp,vValues);
|
|
// CosFov / SinFov,0,0,0
|
|
M.r[0] = vTemp;
|
|
// 0,Height / AspectRatio,0,0
|
|
vTemp = vValues;
|
|
vTemp = _mm_and_ps(vTemp,g_XMMaskY);
|
|
M.r[1] = vTemp;
|
|
// x=fRange,y=-fRange * NearZ,0,-1.0f
|
|
vTemp = _mm_setzero_ps();
|
|
vValues = _mm_shuffle_ps(vValues,g_XMNegIdentityR3,_MM_SHUFFLE(3,2,3,2));
|
|
// 0,0,fRange,-1.0f
|
|
vTemp = _mm_shuffle_ps(vTemp,vValues,_MM_SHUFFLE(3,0,0,0));
|
|
M.r[2] = vTemp;
|
|
// 0,0,fRange * NearZ,0.0f
|
|
vTemp = _mm_shuffle_ps(vTemp,vValues,_MM_SHUFFLE(2,1,0,0));
|
|
M.r[3] = vTemp;
|
|
return M;
|
|
#else // _XM_VMX128_INTRINSICS_
|
|
#endif // _XM_VMX128_INTRINSICS_
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
XMFINLINE XMMATRIX XMMatrixPerspectiveOffCenterLH
|
|
(
|
|
FLOAT ViewLeft,
|
|
FLOAT ViewRight,
|
|
FLOAT ViewBottom,
|
|
FLOAT ViewTop,
|
|
FLOAT NearZ,
|
|
FLOAT FarZ
|
|
)
|
|
{
|
|
#if defined(_XM_NO_INTRINSICS_)
|
|
|
|
FLOAT TwoNearZ;
|
|
FLOAT ReciprocalWidth;
|
|
FLOAT ReciprocalHeight;
|
|
XMMATRIX M;
|
|
|
|
XMASSERT(!XMScalarNearEqual(ViewRight, ViewLeft, 0.00001f));
|
|
XMASSERT(!XMScalarNearEqual(ViewTop, ViewBottom, 0.00001f));
|
|
XMASSERT(!XMScalarNearEqual(FarZ, NearZ, 0.00001f));
|
|
|
|
TwoNearZ = NearZ + NearZ;
|
|
ReciprocalWidth = 1.0f / (ViewRight - ViewLeft);
|
|
ReciprocalHeight = 1.0f / (ViewTop - ViewBottom);
|
|
|
|
M.r[0] = XMVectorSet(TwoNearZ * ReciprocalWidth, 0.0f, 0.0f, 0.0f);
|
|
M.r[1] = XMVectorSet(0.0f, TwoNearZ * ReciprocalHeight, 0.0f, 0.0f);
|
|
M.r[2] = XMVectorSet(-(ViewLeft + ViewRight) * ReciprocalWidth,
|
|
-(ViewTop + ViewBottom) * ReciprocalHeight,
|
|
FarZ / (FarZ - NearZ),
|
|
1.0f);
|
|
M.r[3] = XMVectorSet(0.0f, 0.0f, -M.r[2].vector4_f32[2] * NearZ, 0.0f);
|
|
|
|
return M;
|
|
|
|
#elif defined(_XM_SSE_INTRINSICS_)
|
|
XMASSERT(!XMScalarNearEqual(ViewRight, ViewLeft, 0.00001f));
|
|
XMASSERT(!XMScalarNearEqual(ViewTop, ViewBottom, 0.00001f));
|
|
XMASSERT(!XMScalarNearEqual(FarZ, NearZ, 0.00001f));
|
|
XMMATRIX M;
|
|
FLOAT TwoNearZ = NearZ+NearZ;
|
|
FLOAT ReciprocalWidth = 1.0f / (ViewRight - ViewLeft);
|
|
FLOAT ReciprocalHeight = 1.0f / (ViewTop - ViewBottom);
|
|
FLOAT fRange = FarZ / (FarZ-NearZ);
|
|
// Note: This is recorded on the stack
|
|
XMVECTOR rMem = {
|
|
TwoNearZ*ReciprocalWidth,
|
|
TwoNearZ*ReciprocalHeight,
|
|
-fRange * NearZ,
|
|
0
|
|
};
|
|
// Copy from memory to SSE register
|
|
XMVECTOR vValues = rMem;
|
|
XMVECTOR vTemp = _mm_setzero_ps();
|
|
// Copy x only
|
|
vTemp = _mm_move_ss(vTemp,vValues);
|
|
// TwoNearZ*ReciprocalWidth,0,0,0
|
|
M.r[0] = vTemp;
|
|
// 0,TwoNearZ*ReciprocalHeight,0,0
|
|
vTemp = vValues;
|
|
vTemp = _mm_and_ps(vTemp,g_XMMaskY);
|
|
M.r[1] = vTemp;
|
|
// 0,0,fRange,1.0f
|
|
M.m[2][0] = -(ViewLeft + ViewRight) * ReciprocalWidth;
|
|
M.m[2][1] = -(ViewTop + ViewBottom) * ReciprocalHeight;
|
|
M.m[2][2] = fRange;
|
|
M.m[2][3] = 1.0f;
|
|
// 0,0,-fRange * NearZ,0.0f
|
|
vValues = _mm_and_ps(vValues,g_XMMaskZ);
|
|
M.r[3] = vValues;
|
|
return M;
|
|
#else // _XM_VMX128_INTRINSICS_
|
|
#endif // _XM_VMX128_INTRINSICS_
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
XMFINLINE XMMATRIX XMMatrixPerspectiveOffCenterRH
|
|
(
|
|
FLOAT ViewLeft,
|
|
FLOAT ViewRight,
|
|
FLOAT ViewBottom,
|
|
FLOAT ViewTop,
|
|
FLOAT NearZ,
|
|
FLOAT FarZ
|
|
)
|
|
{
|
|
#if defined(_XM_NO_INTRINSICS_)
|
|
|
|
FLOAT TwoNearZ;
|
|
FLOAT ReciprocalWidth;
|
|
FLOAT ReciprocalHeight;
|
|
XMMATRIX M;
|
|
|
|
XMASSERT(!XMScalarNearEqual(ViewRight, ViewLeft, 0.00001f));
|
|
XMASSERT(!XMScalarNearEqual(ViewTop, ViewBottom, 0.00001f));
|
|
XMASSERT(!XMScalarNearEqual(FarZ, NearZ, 0.00001f));
|
|
|
|
TwoNearZ = NearZ + NearZ;
|
|
ReciprocalWidth = 1.0f / (ViewRight - ViewLeft);
|
|
ReciprocalHeight = 1.0f / (ViewTop - ViewBottom);
|
|
|
|
M.r[0] = XMVectorSet(TwoNearZ * ReciprocalWidth, 0.0f, 0.0f, 0.0f);
|
|
M.r[1] = XMVectorSet(0.0f, TwoNearZ * ReciprocalHeight, 0.0f, 0.0f);
|
|
M.r[2] = XMVectorSet((ViewLeft + ViewRight) * ReciprocalWidth,
|
|
(ViewTop + ViewBottom) * ReciprocalHeight,
|
|
FarZ / (NearZ - FarZ),
|
|
-1.0f);
|
|
M.r[3] = XMVectorSet(0.0f, 0.0f, M.r[2].vector4_f32[2] * NearZ, 0.0f);
|
|
|
|
return M;
|
|
|
|
#elif defined(_XM_SSE_INTRINSICS_)
|
|
XMASSERT(!XMScalarNearEqual(ViewRight, ViewLeft, 0.00001f));
|
|
XMASSERT(!XMScalarNearEqual(ViewTop, ViewBottom, 0.00001f));
|
|
XMASSERT(!XMScalarNearEqual(FarZ, NearZ, 0.00001f));
|
|
|
|
XMMATRIX M;
|
|
FLOAT TwoNearZ = NearZ+NearZ;
|
|
FLOAT ReciprocalWidth = 1.0f / (ViewRight - ViewLeft);
|
|
FLOAT ReciprocalHeight = 1.0f / (ViewTop - ViewBottom);
|
|
FLOAT fRange = FarZ / (NearZ-FarZ);
|
|
// Note: This is recorded on the stack
|
|
XMVECTOR rMem = {
|
|
TwoNearZ*ReciprocalWidth,
|
|
TwoNearZ*ReciprocalHeight,
|
|
fRange * NearZ,
|
|
0
|
|
};
|
|
// Copy from memory to SSE register
|
|
XMVECTOR vValues = rMem;
|
|
XMVECTOR vTemp = _mm_setzero_ps();
|
|
// Copy x only
|
|
vTemp = _mm_move_ss(vTemp,vValues);
|
|
// TwoNearZ*ReciprocalWidth,0,0,0
|
|
M.r[0] = vTemp;
|
|
// 0,TwoNearZ*ReciprocalHeight,0,0
|
|
vTemp = vValues;
|
|
vTemp = _mm_and_ps(vTemp,g_XMMaskY);
|
|
M.r[1] = vTemp;
|
|
// 0,0,fRange,1.0f
|
|
M.m[2][0] = (ViewLeft + ViewRight) * ReciprocalWidth;
|
|
M.m[2][1] = (ViewTop + ViewBottom) * ReciprocalHeight;
|
|
M.m[2][2] = fRange;
|
|
M.m[2][3] = -1.0f;
|
|
// 0,0,-fRange * NearZ,0.0f
|
|
vValues = _mm_and_ps(vValues,g_XMMaskZ);
|
|
M.r[3] = vValues;
|
|
return M;
|
|
#else // _XM_VMX128_INTRINSICS_
|
|
#endif // _XM_VMX128_INTRINSICS_
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
XMFINLINE XMMATRIX XMMatrixOrthographicLH
|
|
(
|
|
FLOAT ViewWidth,
|
|
FLOAT ViewHeight,
|
|
FLOAT NearZ,
|
|
FLOAT FarZ
|
|
)
|
|
{
|
|
#if defined(_XM_NO_INTRINSICS_)
|
|
|
|
FLOAT fRange;
|
|
XMMATRIX M;
|
|
|
|
XMASSERT(!XMScalarNearEqual(ViewWidth, 0.0f, 0.00001f));
|
|
XMASSERT(!XMScalarNearEqual(ViewHeight, 0.0f, 0.00001f));
|
|
XMASSERT(!XMScalarNearEqual(FarZ, NearZ, 0.00001f));
|
|
|
|
fRange = 1.0f / (FarZ-NearZ);
|
|
M.r[0] = XMVectorSet(2.0f / ViewWidth, 0.0f, 0.0f, 0.0f);
|
|
M.r[1] = XMVectorSet(0.0f, 2.0f / ViewHeight, 0.0f, 0.0f);
|
|
M.r[2] = XMVectorSet(0.0f, 0.0f, fRange, 0.0f);
|
|
M.r[3] = XMVectorSet(0.0f, 0.0f, -fRange * NearZ, 1.0f);
|
|
|
|
return M;
|
|
|
|
#elif defined(_XM_SSE_INTRINSICS_)
|
|
XMASSERT(!XMScalarNearEqual(ViewWidth, 0.0f, 0.00001f));
|
|
XMASSERT(!XMScalarNearEqual(ViewHeight, 0.0f, 0.00001f));
|
|
XMASSERT(!XMScalarNearEqual(FarZ, NearZ, 0.00001f));
|
|
XMMATRIX M;
|
|
FLOAT fRange = 1.0f / (FarZ-NearZ);
|
|
// Note: This is recorded on the stack
|
|
XMVECTOR rMem = {
|
|
2.0f / ViewWidth,
|
|
2.0f / ViewHeight,
|
|
fRange,
|
|
-fRange * NearZ
|
|
};
|
|
// Copy from memory to SSE register
|
|
XMVECTOR vValues = rMem;
|
|
XMVECTOR vTemp = _mm_setzero_ps();
|
|
// Copy x only
|
|
vTemp = _mm_move_ss(vTemp,vValues);
|
|
// 2.0f / ViewWidth,0,0,0
|
|
M.r[0] = vTemp;
|
|
// 0,2.0f / ViewHeight,0,0
|
|
vTemp = vValues;
|
|
vTemp = _mm_and_ps(vTemp,g_XMMaskY);
|
|
M.r[1] = vTemp;
|
|
// x=fRange,y=-fRange * NearZ,0,1.0f
|
|
vTemp = _mm_setzero_ps();
|
|
vValues = _mm_shuffle_ps(vValues,g_XMIdentityR3,_MM_SHUFFLE(3,2,3,2));
|
|
// 0,0,fRange,0.0f
|
|
vTemp = _mm_shuffle_ps(vTemp,vValues,_MM_SHUFFLE(2,0,0,0));
|
|
M.r[2] = vTemp;
|
|
// 0,0,-fRange * NearZ,1.0f
|
|
vTemp = _mm_shuffle_ps(vTemp,vValues,_MM_SHUFFLE(3,1,0,0));
|
|
M.r[3] = vTemp;
|
|
return M;
|
|
#else // _XM_VMX128_INTRINSICS_
|
|
#endif // _XM_VMX128_INTRINSICS_
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
XMFINLINE XMMATRIX XMMatrixOrthographicRH
|
|
(
|
|
FLOAT ViewWidth,
|
|
FLOAT ViewHeight,
|
|
FLOAT NearZ,
|
|
FLOAT FarZ
|
|
)
|
|
{
|
|
#if defined(_XM_NO_INTRINSICS_)
|
|
|
|
XMMATRIX M;
|
|
|
|
XMASSERT(!XMScalarNearEqual(ViewWidth, 0.0f, 0.00001f));
|
|
XMASSERT(!XMScalarNearEqual(ViewHeight, 0.0f, 0.00001f));
|
|
XMASSERT(!XMScalarNearEqual(FarZ, NearZ, 0.00001f));
|
|
|
|
M.r[0] = XMVectorSet(2.0f / ViewWidth, 0.0f, 0.0f, 0.0f);
|
|
M.r[1] = XMVectorSet(0.0f, 2.0f / ViewHeight, 0.0f, 0.0f);
|
|
M.r[2] = XMVectorSet(0.0f, 0.0f, 1.0f / (NearZ - FarZ), 0.0f);
|
|
M.r[3] = XMVectorSet(0.0f, 0.0f, M.r[2].vector4_f32[2] * NearZ, 1.0f);
|
|
|
|
return M;
|
|
|
|
#elif defined(_XM_SSE_INTRINSICS_)
|
|
XMASSERT(!XMScalarNearEqual(ViewWidth, 0.0f, 0.00001f));
|
|
XMASSERT(!XMScalarNearEqual(ViewHeight, 0.0f, 0.00001f));
|
|
XMASSERT(!XMScalarNearEqual(FarZ, NearZ, 0.00001f));
|
|
XMMATRIX M;
|
|
FLOAT fRange = 1.0f / (NearZ-FarZ);
|
|
// Note: This is recorded on the stack
|
|
XMVECTOR rMem = {
|
|
2.0f / ViewWidth,
|
|
2.0f / ViewHeight,
|
|
fRange,
|
|
fRange * NearZ
|
|
};
|
|
// Copy from memory to SSE register
|
|
XMVECTOR vValues = rMem;
|
|
XMVECTOR vTemp = _mm_setzero_ps();
|
|
// Copy x only
|
|
vTemp = _mm_move_ss(vTemp,vValues);
|
|
// 2.0f / ViewWidth,0,0,0
|
|
M.r[0] = vTemp;
|
|
// 0,2.0f / ViewHeight,0,0
|
|
vTemp = vValues;
|
|
vTemp = _mm_and_ps(vTemp,g_XMMaskY);
|
|
M.r[1] = vTemp;
|
|
// x=fRange,y=fRange * NearZ,0,1.0f
|
|
vTemp = _mm_setzero_ps();
|
|
vValues = _mm_shuffle_ps(vValues,g_XMIdentityR3,_MM_SHUFFLE(3,2,3,2));
|
|
// 0,0,fRange,0.0f
|
|
vTemp = _mm_shuffle_ps(vTemp,vValues,_MM_SHUFFLE(2,0,0,0));
|
|
M.r[2] = vTemp;
|
|
// 0,0,fRange * NearZ,1.0f
|
|
vTemp = _mm_shuffle_ps(vTemp,vValues,_MM_SHUFFLE(3,1,0,0));
|
|
M.r[3] = vTemp;
|
|
return M;
|
|
#else // _XM_VMX128_INTRINSICS_
|
|
#endif // _XM_VMX128_INTRINSICS_
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
XMFINLINE XMMATRIX XMMatrixOrthographicOffCenterLH
|
|
(
|
|
FLOAT ViewLeft,
|
|
FLOAT ViewRight,
|
|
FLOAT ViewBottom,
|
|
FLOAT ViewTop,
|
|
FLOAT NearZ,
|
|
FLOAT FarZ
|
|
)
|
|
{
|
|
#if defined(_XM_NO_INTRINSICS_)
|
|
|
|
FLOAT ReciprocalWidth;
|
|
FLOAT ReciprocalHeight;
|
|
XMMATRIX M;
|
|
|
|
XMASSERT(!XMScalarNearEqual(ViewRight, ViewLeft, 0.00001f));
|
|
XMASSERT(!XMScalarNearEqual(ViewTop, ViewBottom, 0.00001f));
|
|
XMASSERT(!XMScalarNearEqual(FarZ, NearZ, 0.00001f));
|
|
|
|
ReciprocalWidth = 1.0f / (ViewRight - ViewLeft);
|
|
ReciprocalHeight = 1.0f / (ViewTop - ViewBottom);
|
|
|
|
M.r[0] = XMVectorSet(ReciprocalWidth + ReciprocalWidth, 0.0f, 0.0f, 0.0f);
|
|
M.r[1] = XMVectorSet(0.0f, ReciprocalHeight + ReciprocalHeight, 0.0f, 0.0f);
|
|
M.r[2] = XMVectorSet(0.0f, 0.0f, 1.0f / (FarZ - NearZ), 0.0f);
|
|
M.r[3] = XMVectorSet(-(ViewLeft + ViewRight) * ReciprocalWidth,
|
|
-(ViewTop + ViewBottom) * ReciprocalHeight,
|
|
-M.r[2].vector4_f32[2] * NearZ,
|
|
1.0f);
|
|
|
|
return M;
|
|
|
|
#elif defined(_XM_SSE_INTRINSICS_)
|
|
XMMATRIX M;
|
|
FLOAT fReciprocalWidth = 1.0f / (ViewRight - ViewLeft);
|
|
FLOAT fReciprocalHeight = 1.0f / (ViewTop - ViewBottom);
|
|
FLOAT fRange = 1.0f / (FarZ-NearZ);
|
|
// Note: This is recorded on the stack
|
|
XMVECTOR rMem = {
|
|
fReciprocalWidth,
|
|
fReciprocalHeight,
|
|
fRange,
|
|
1.0f
|
|
};
|
|
XMVECTOR rMem2 = {
|
|
-(ViewLeft + ViewRight),
|
|
-(ViewTop + ViewBottom),
|
|
-NearZ,
|
|
1.0f
|
|
};
|
|
// Copy from memory to SSE register
|
|
XMVECTOR vValues = rMem;
|
|
XMVECTOR vTemp = _mm_setzero_ps();
|
|
// Copy x only
|
|
vTemp = _mm_move_ss(vTemp,vValues);
|
|
// fReciprocalWidth*2,0,0,0
|
|
vTemp = _mm_add_ss(vTemp,vTemp);
|
|
M.r[0] = vTemp;
|
|
// 0,fReciprocalHeight*2,0,0
|
|
vTemp = vValues;
|
|
vTemp = _mm_and_ps(vTemp,g_XMMaskY);
|
|
vTemp = _mm_add_ps(vTemp,vTemp);
|
|
M.r[1] = vTemp;
|
|
// 0,0,fRange,0.0f
|
|
vTemp = vValues;
|
|
vTemp = _mm_and_ps(vTemp,g_XMMaskZ);
|
|
M.r[2] = vTemp;
|
|
// -(ViewLeft + ViewRight)*fReciprocalWidth,-(ViewTop + ViewBottom)*fReciprocalHeight,fRange*-NearZ,1.0f
|
|
vValues = _mm_mul_ps(vValues,rMem2);
|
|
M.r[3] = vValues;
|
|
return M;
|
|
#else // _XM_VMX128_INTRINSICS_
|
|
#endif // _XM_VMX128_INTRINSICS_
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
XMFINLINE XMMATRIX XMMatrixOrthographicOffCenterRH
|
|
(
|
|
FLOAT ViewLeft,
|
|
FLOAT ViewRight,
|
|
FLOAT ViewBottom,
|
|
FLOAT ViewTop,
|
|
FLOAT NearZ,
|
|
FLOAT FarZ
|
|
)
|
|
{
|
|
#if defined(_XM_NO_INTRINSICS_)
|
|
|
|
FLOAT ReciprocalWidth;
|
|
FLOAT ReciprocalHeight;
|
|
XMMATRIX M;
|
|
|
|
XMASSERT(!XMScalarNearEqual(ViewRight, ViewLeft, 0.00001f));
|
|
XMASSERT(!XMScalarNearEqual(ViewTop, ViewBottom, 0.00001f));
|
|
XMASSERT(!XMScalarNearEqual(FarZ, NearZ, 0.00001f));
|
|
|
|
ReciprocalWidth = 1.0f / (ViewRight - ViewLeft);
|
|
ReciprocalHeight = 1.0f / (ViewTop - ViewBottom);
|
|
|
|
M.r[0] = XMVectorSet(ReciprocalWidth + ReciprocalWidth, 0.0f, 0.0f, 0.0f);
|
|
M.r[1] = XMVectorSet(0.0f, ReciprocalHeight + ReciprocalHeight, 0.0f, 0.0f);
|
|
M.r[2] = XMVectorSet(0.0f, 0.0f, 1.0f / (NearZ - FarZ), 0.0f);
|
|
M.r[3] = XMVectorSet(-(ViewLeft + ViewRight) * ReciprocalWidth,
|
|
-(ViewTop + ViewBottom) * ReciprocalHeight,
|
|
M.r[2].vector4_f32[2] * NearZ,
|
|
1.0f);
|
|
|
|
return M;
|
|
|
|
#elif defined(_XM_SSE_INTRINSICS_)
|
|
XMMATRIX M;
|
|
FLOAT fReciprocalWidth = 1.0f / (ViewRight - ViewLeft);
|
|
FLOAT fReciprocalHeight = 1.0f / (ViewTop - ViewBottom);
|
|
FLOAT fRange = 1.0f / (NearZ-FarZ);
|
|
// Note: This is recorded on the stack
|
|
XMVECTOR rMem = {
|
|
fReciprocalWidth,
|
|
fReciprocalHeight,
|
|
fRange,
|
|
1.0f
|
|
};
|
|
XMVECTOR rMem2 = {
|
|
-(ViewLeft + ViewRight),
|
|
-(ViewTop + ViewBottom),
|
|
NearZ,
|
|
1.0f
|
|
};
|
|
// Copy from memory to SSE register
|
|
XMVECTOR vValues = rMem;
|
|
XMVECTOR vTemp = _mm_setzero_ps();
|
|
// Copy x only
|
|
vTemp = _mm_move_ss(vTemp,vValues);
|
|
// fReciprocalWidth*2,0,0,0
|
|
vTemp = _mm_add_ss(vTemp,vTemp);
|
|
M.r[0] = vTemp;
|
|
// 0,fReciprocalHeight*2,0,0
|
|
vTemp = vValues;
|
|
vTemp = _mm_and_ps(vTemp,g_XMMaskY);
|
|
vTemp = _mm_add_ps(vTemp,vTemp);
|
|
M.r[1] = vTemp;
|
|
// 0,0,fRange,0.0f
|
|
vTemp = vValues;
|
|
vTemp = _mm_and_ps(vTemp,g_XMMaskZ);
|
|
M.r[2] = vTemp;
|
|
// -(ViewLeft + ViewRight)*fReciprocalWidth,-(ViewTop + ViewBottom)*fReciprocalHeight,fRange*-NearZ,1.0f
|
|
vValues = _mm_mul_ps(vValues,rMem2);
|
|
M.r[3] = vValues;
|
|
return M;
|
|
#else // _XM_VMX128_INTRINSICS_
|
|
#endif // _XM_VMX128_INTRINSICS_
|
|
}
|
|
|
|
#ifdef __cplusplus
|
|
|
|
/****************************************************************************
|
|
*
|
|
* XMMATRIX operators and methods
|
|
*
|
|
****************************************************************************/
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
XMFINLINE _XMMATRIX::_XMMATRIX
|
|
(
|
|
FXMVECTOR R0,
|
|
FXMVECTOR R1,
|
|
FXMVECTOR R2,
|
|
CXMVECTOR R3
|
|
)
|
|
{
|
|
r[0] = R0;
|
|
r[1] = R1;
|
|
r[2] = R2;
|
|
r[3] = R3;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
XMFINLINE _XMMATRIX::_XMMATRIX
|
|
(
|
|
FLOAT m00, FLOAT m01, FLOAT m02, FLOAT m03,
|
|
FLOAT m10, FLOAT m11, FLOAT m12, FLOAT m13,
|
|
FLOAT m20, FLOAT m21, FLOAT m22, FLOAT m23,
|
|
FLOAT m30, FLOAT m31, FLOAT m32, FLOAT m33
|
|
)
|
|
{
|
|
r[0] = XMVectorSet(m00, m01, m02, m03);
|
|
r[1] = XMVectorSet(m10, m11, m12, m13);
|
|
r[2] = XMVectorSet(m20, m21, m22, m23);
|
|
r[3] = XMVectorSet(m30, m31, m32, m33);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
XMFINLINE _XMMATRIX::_XMMATRIX
|
|
(
|
|
CONST FLOAT* pArray
|
|
)
|
|
{
|
|
r[0] = XMLoadFloat4((XMFLOAT4*)pArray);
|
|
r[1] = XMLoadFloat4((XMFLOAT4*)(pArray + 4));
|
|
r[2] = XMLoadFloat4((XMFLOAT4*)(pArray + 8));
|
|
r[3] = XMLoadFloat4((XMFLOAT4*)(pArray + 12));
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
XMFINLINE _XMMATRIX& _XMMATRIX::operator=
|
|
(
|
|
CONST _XMMATRIX& M
|
|
)
|
|
{
|
|
r[0] = M.r[0];
|
|
r[1] = M.r[1];
|
|
r[2] = M.r[2];
|
|
r[3] = M.r[3];
|
|
return *this;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
#ifndef XM_NO_OPERATOR_OVERLOADS
|
|
|
|
#if !defined(_XBOX_VER) && defined(_XM_ISVS2005_) && defined(_XM_X64_)
|
|
#pragma warning(push)
|
|
#pragma warning(disable : 4328)
|
|
#endif
|
|
|
|
XMFINLINE _XMMATRIX& _XMMATRIX::operator*=
|
|
(
|
|
CONST _XMMATRIX& M
|
|
)
|
|
{
|
|
*this = XMMatrixMultiply(*this, M);
|
|
return *this;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
XMFINLINE _XMMATRIX _XMMATRIX::operator*
|
|
(
|
|
CONST _XMMATRIX& M
|
|
) CONST
|
|
{
|
|
return XMMatrixMultiply(*this, M);
|
|
}
|
|
|
|
#if !defined(_XBOX_VER) && defined(_XM_ISVS2005_) && defined(_XM_X64_)
|
|
#pragma warning(pop)
|
|
#endif
|
|
|
|
#endif // !XM_NO_OPERATOR_OVERLOADS
|
|
|
|
/****************************************************************************
|
|
*
|
|
* XMFLOAT3X3 operators
|
|
*
|
|
****************************************************************************/
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
XMFINLINE _XMFLOAT3X3::_XMFLOAT3X3
|
|
(
|
|
FLOAT m00, FLOAT m01, FLOAT m02,
|
|
FLOAT m10, FLOAT m11, FLOAT m12,
|
|
FLOAT m20, FLOAT m21, FLOAT m22
|
|
)
|
|
{
|
|
m[0][0] = m00;
|
|
m[0][1] = m01;
|
|
m[0][2] = m02;
|
|
|
|
m[1][0] = m10;
|
|
m[1][1] = m11;
|
|
m[1][2] = m12;
|
|
|
|
m[2][0] = m20;
|
|
m[2][1] = m21;
|
|
m[2][2] = m22;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
XMFINLINE _XMFLOAT3X3::_XMFLOAT3X3
|
|
(
|
|
CONST FLOAT* pArray
|
|
)
|
|
{
|
|
UINT Row;
|
|
UINT Column;
|
|
|
|
for (Row = 0; Row < 3; Row++)
|
|
{
|
|
for (Column = 0; Column < 3; Column++)
|
|
{
|
|
m[Row][Column] = pArray[Row * 3 + Column];
|
|
}
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
XMFINLINE _XMFLOAT3X3& _XMFLOAT3X3::operator=
|
|
(
|
|
CONST _XMFLOAT3X3& Float3x3
|
|
)
|
|
{
|
|
_11 = Float3x3._11;
|
|
_12 = Float3x3._12;
|
|
_13 = Float3x3._13;
|
|
_21 = Float3x3._21;
|
|
_22 = Float3x3._22;
|
|
_23 = Float3x3._23;
|
|
_31 = Float3x3._31;
|
|
_32 = Float3x3._32;
|
|
_33 = Float3x3._33;
|
|
|
|
return *this;
|
|
}
|
|
|
|
/****************************************************************************
|
|
*
|
|
* XMFLOAT4X3 operators
|
|
*
|
|
****************************************************************************/
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
XMFINLINE _XMFLOAT4X3::_XMFLOAT4X3
|
|
(
|
|
FLOAT m00, FLOAT m01, FLOAT m02,
|
|
FLOAT m10, FLOAT m11, FLOAT m12,
|
|
FLOAT m20, FLOAT m21, FLOAT m22,
|
|
FLOAT m30, FLOAT m31, FLOAT m32
|
|
)
|
|
{
|
|
m[0][0] = m00;
|
|
m[0][1] = m01;
|
|
m[0][2] = m02;
|
|
|
|
m[1][0] = m10;
|
|
m[1][1] = m11;
|
|
m[1][2] = m12;
|
|
|
|
m[2][0] = m20;
|
|
m[2][1] = m21;
|
|
m[2][2] = m22;
|
|
|
|
m[3][0] = m30;
|
|
m[3][1] = m31;
|
|
m[3][2] = m32;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
XMFINLINE _XMFLOAT4X3::_XMFLOAT4X3
|
|
(
|
|
CONST FLOAT* pArray
|
|
)
|
|
{
|
|
UINT Row;
|
|
UINT Column;
|
|
|
|
for (Row = 0; Row < 4; Row++)
|
|
{
|
|
for (Column = 0; Column < 3; Column++)
|
|
{
|
|
m[Row][Column] = pArray[Row * 3 + Column];
|
|
}
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
XMFINLINE _XMFLOAT4X3& _XMFLOAT4X3::operator=
|
|
(
|
|
CONST _XMFLOAT4X3& Float4x3
|
|
)
|
|
{
|
|
XMVECTOR V1 = XMLoadFloat4((XMFLOAT4*)&Float4x3._11);
|
|
XMVECTOR V2 = XMLoadFloat4((XMFLOAT4*)&Float4x3._22);
|
|
XMVECTOR V3 = XMLoadFloat4((XMFLOAT4*)&Float4x3._33);
|
|
|
|
XMStoreFloat4((XMFLOAT4*)&_11, V1);
|
|
XMStoreFloat4((XMFLOAT4*)&_22, V2);
|
|
XMStoreFloat4((XMFLOAT4*)&_33, V3);
|
|
|
|
return *this;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
XMFINLINE XMFLOAT4X3A& XMFLOAT4X3A::operator=
|
|
(
|
|
CONST XMFLOAT4X3A& Float4x3
|
|
)
|
|
{
|
|
XMVECTOR V1 = XMLoadFloat4A((XMFLOAT4A*)&Float4x3._11);
|
|
XMVECTOR V2 = XMLoadFloat4A((XMFLOAT4A*)&Float4x3._22);
|
|
XMVECTOR V3 = XMLoadFloat4A((XMFLOAT4A*)&Float4x3._33);
|
|
|
|
XMStoreFloat4A((XMFLOAT4A*)&_11, V1);
|
|
XMStoreFloat4A((XMFLOAT4A*)&_22, V2);
|
|
XMStoreFloat4A((XMFLOAT4A*)&_33, V3);
|
|
|
|
return *this;
|
|
}
|
|
|
|
/****************************************************************************
|
|
*
|
|
* XMFLOAT4X4 operators
|
|
*
|
|
****************************************************************************/
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
XMFINLINE _XMFLOAT4X4::_XMFLOAT4X4
|
|
(
|
|
FLOAT m00, FLOAT m01, FLOAT m02, FLOAT m03,
|
|
FLOAT m10, FLOAT m11, FLOAT m12, FLOAT m13,
|
|
FLOAT m20, FLOAT m21, FLOAT m22, FLOAT m23,
|
|
FLOAT m30, FLOAT m31, FLOAT m32, FLOAT m33
|
|
)
|
|
{
|
|
m[0][0] = m00;
|
|
m[0][1] = m01;
|
|
m[0][2] = m02;
|
|
m[0][3] = m03;
|
|
|
|
m[1][0] = m10;
|
|
m[1][1] = m11;
|
|
m[1][2] = m12;
|
|
m[1][3] = m13;
|
|
|
|
m[2][0] = m20;
|
|
m[2][1] = m21;
|
|
m[2][2] = m22;
|
|
m[2][3] = m23;
|
|
|
|
m[3][0] = m30;
|
|
m[3][1] = m31;
|
|
m[3][2] = m32;
|
|
m[3][3] = m33;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
XMFINLINE _XMFLOAT4X4::_XMFLOAT4X4
|
|
(
|
|
CONST FLOAT* pArray
|
|
)
|
|
{
|
|
UINT Row;
|
|
UINT Column;
|
|
|
|
for (Row = 0; Row < 4; Row++)
|
|
{
|
|
for (Column = 0; Column < 4; Column++)
|
|
{
|
|
m[Row][Column] = pArray[Row * 4 + Column];
|
|
}
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
XMFINLINE _XMFLOAT4X4& _XMFLOAT4X4::operator=
|
|
(
|
|
CONST _XMFLOAT4X4& Float4x4
|
|
)
|
|
{
|
|
XMVECTOR V1 = XMLoadFloat4((XMFLOAT4*)&Float4x4._11);
|
|
XMVECTOR V2 = XMLoadFloat4((XMFLOAT4*)&Float4x4._21);
|
|
XMVECTOR V3 = XMLoadFloat4((XMFLOAT4*)&Float4x4._31);
|
|
XMVECTOR V4 = XMLoadFloat4((XMFLOAT4*)&Float4x4._41);
|
|
|
|
XMStoreFloat4((XMFLOAT4*)&_11, V1);
|
|
XMStoreFloat4((XMFLOAT4*)&_21, V2);
|
|
XMStoreFloat4((XMFLOAT4*)&_31, V3);
|
|
XMStoreFloat4((XMFLOAT4*)&_41, V4);
|
|
|
|
return *this;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
XMFINLINE XMFLOAT4X4A& XMFLOAT4X4A::operator=
|
|
(
|
|
CONST XMFLOAT4X4A& Float4x4
|
|
)
|
|
{
|
|
XMVECTOR V1 = XMLoadFloat4A((XMFLOAT4A*)&Float4x4._11);
|
|
XMVECTOR V2 = XMLoadFloat4A((XMFLOAT4A*)&Float4x4._21);
|
|
XMVECTOR V3 = XMLoadFloat4A((XMFLOAT4A*)&Float4x4._31);
|
|
XMVECTOR V4 = XMLoadFloat4A((XMFLOAT4A*)&Float4x4._41);
|
|
|
|
XMStoreFloat4A((XMFLOAT4A*)&_11, V1);
|
|
XMStoreFloat4A((XMFLOAT4A*)&_21, V2);
|
|
XMStoreFloat4A((XMFLOAT4A*)&_31, V3);
|
|
XMStoreFloat4A((XMFLOAT4A*)&_41, V4);
|
|
|
|
return *this;
|
|
}
|
|
|
|
#endif // __cplusplus
|
|
|
|
#endif // __XNAMATHMATRIX_INL__
|
|
|