mirror of
https://github.com/microsoft/DirectXMath
synced 2024-11-21 20:00:12 +00:00
Fixed conformance warnings based on clang (#75)
This commit is contained in:
Chuck Walbourn
GitHub
parent
2e08f92a3c
commit
6883c5518a
@ -18,14 +18,14 @@ enum ContainmentType
|
||||
{
|
||||
DISJOINT = 0,
|
||||
INTERSECTS = 1,
|
||||
CONTAINS = 2,
|
||||
CONTAINS = 2
|
||||
};
|
||||
|
||||
enum PlaneIntersectionType
|
||||
{
|
||||
FRONT = 0,
|
||||
INTERSECTING = 1,
|
||||
BACK = 2,
|
||||
BACK = 2
|
||||
};
|
||||
|
||||
struct BoundingBox;
|
||||
@ -319,7 +319,7 @@ namespace TriangleTests
|
||||
_In_ GXMVECTOR Plane0, _In_ HXMVECTOR Plane1, _In_ HXMVECTOR Plane2,
|
||||
_In_ CXMVECTOR Plane3, _In_ CXMVECTOR Plane4, _In_ CXMVECTOR Plane5 );
|
||||
// Test a triangle against six planes at once (see BoundingFrustum::GetPlanes)
|
||||
};
|
||||
}
|
||||
|
||||
#pragma warning(pop)
|
||||
|
||||
|
||||
@ -192,9 +192,9 @@ inline XMVECTOR CalculateEigenVector( _In_ float m11, _In_ float m12, _In_ float
|
||||
_In_ float m22, _In_ float m23, _In_ float m33, _In_ float e )
|
||||
{
|
||||
float fTmp[3];
|
||||
fTmp[0] = ( float )( m12 * m23 - m13 * ( m22 - e ) );
|
||||
fTmp[1] = ( float )( m13 * m12 - m23 * ( m11 - e ) );
|
||||
fTmp[2] = ( float )( ( m11 - e ) * ( m22 - e ) - m12 * m12 );
|
||||
fTmp[0] = m12 * m23 - m13 * ( m22 - e );
|
||||
fTmp[1] = m13 * m12 - m23 * ( m11 - e );
|
||||
fTmp[2] = ( m11 - e ) * ( m22 - e ) - m12 * m12;
|
||||
|
||||
XMVECTOR vTmp = XMLoadFloat3( reinterpret_cast<const XMFLOAT3*>(fTmp) );
|
||||
|
||||
@ -236,11 +236,11 @@ inline XMVECTOR CalculateEigenVector( _In_ float m11, _In_ float m12, _In_ float
|
||||
vTmp = XMVectorSetZ( vTmp, 0.0f );
|
||||
// recalculate y to make equation work
|
||||
if( m12 != 0 )
|
||||
vTmp = XMVectorSetY( vTmp, ( float )( -f1 / f2 ) );
|
||||
vTmp = XMVectorSetY( vTmp, -f1 / f2 );
|
||||
}
|
||||
else
|
||||
{
|
||||
vTmp = XMVectorSetZ( vTmp, ( float )( ( f2 - f1 ) / f3 ) );
|
||||
vTmp = XMVectorSetZ( vTmp, ( f2 - f1 ) / f3 );
|
||||
}
|
||||
}
|
||||
|
||||
@ -2006,7 +2006,7 @@ inline void XM_CALLCONV BoundingOrientedBox::Transform( BoundingOrientedBox& Out
|
||||
_Use_decl_annotations_
|
||||
inline void BoundingOrientedBox::GetCorners( XMFLOAT3* Corners ) const
|
||||
{
|
||||
assert( Corners != 0 );
|
||||
assert( Corners != nullptr );
|
||||
|
||||
// Load the box
|
||||
XMVECTOR vCenter = XMLoadFloat3( &Center );
|
||||
@ -2698,7 +2698,7 @@ _Use_decl_annotations_
|
||||
inline void BoundingOrientedBox::CreateFromPoints( BoundingOrientedBox& Out, size_t Count, const XMFLOAT3* pPoints, size_t Stride )
|
||||
{
|
||||
assert( Count > 0 );
|
||||
assert( pPoints != 0 );
|
||||
assert( pPoints != nullptr );
|
||||
|
||||
XMVECTOR CenterOfMass = XMVectorZero();
|
||||
|
||||
@ -2895,7 +2895,7 @@ inline void XM_CALLCONV BoundingFrustum::Transform( BoundingFrustum& Out, float
|
||||
_Use_decl_annotations_
|
||||
inline void BoundingFrustum::GetCorners( XMFLOAT3* Corners ) const
|
||||
{
|
||||
assert( Corners != 0 );
|
||||
assert( Corners != nullptr );
|
||||
|
||||
// Load origin and orientation of the frustum.
|
||||
XMVECTOR vOrigin = XMLoadFloat3( &Origin );
|
||||
|
||||
@ -1666,7 +1666,7 @@ namespace Internal
|
||||
{
|
||||
static XMVECTOR XM_CALLCONV Permute(FXMVECTOR v1, FXMVECTOR v2) { return _mm_shuffle_ps(v2, v1, Shuffle); }
|
||||
};
|
||||
};
|
||||
}
|
||||
|
||||
#endif // _XM_SSE_INTRINSICS_ && !_XM_NO_INTRINSICS_
|
||||
|
||||
@ -1944,12 +1944,12 @@ XMGLOBALCONST XMVECTORI32 g_XMFltMax = { { { 0x7F7FFFFF, 0x7F7FFF
|
||||
XMGLOBALCONST XMVECTORU32 g_XMNegOneMask = { { { 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF } } };
|
||||
XMGLOBALCONST XMVECTORU32 g_XMMaskA8R8G8B8 = { { { 0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000 } } };
|
||||
XMGLOBALCONST XMVECTORU32 g_XMFlipA8R8G8B8 = { { { 0x00000000, 0x00000000, 0x00000000, 0x80000000 } } };
|
||||
XMGLOBALCONST XMVECTORF32 g_XMFixAA8R8G8B8 = { { { 0.0f, 0.0f, 0.0f, (float) (0x80000000U) } } };
|
||||
XMGLOBALCONST XMVECTORF32 g_XMNormalizeA8R8G8B8 = { { { 1.0f / (255.0f*(float) (0x10000)), 1.0f / (255.0f*(float) (0x100)), 1.0f / 255.0f, 1.0f / (255.0f*(float) (0x1000000)) } } };
|
||||
XMGLOBALCONST XMVECTORF32 g_XMFixAA8R8G8B8 = { { { 0.0f, 0.0f, 0.0f, float(0x80000000U) } } };
|
||||
XMGLOBALCONST XMVECTORF32 g_XMNormalizeA8R8G8B8 = { { { 1.0f / (255.0f*float(0x10000)), 1.0f / (255.0f*float(0x100)), 1.0f / 255.0f, 1.0f / (255.0f*float(0x1000000)) } } };
|
||||
XMGLOBALCONST XMVECTORU32 g_XMMaskA2B10G10R10 = { { { 0x000003FF, 0x000FFC00, 0x3FF00000, 0xC0000000 } } };
|
||||
XMGLOBALCONST XMVECTORU32 g_XMFlipA2B10G10R10 = { { { 0x00000200, 0x00080000, 0x20000000, 0x80000000 } } };
|
||||
XMGLOBALCONST XMVECTORF32 g_XMFixAA2B10G10R10 = { { { -512.0f, -512.0f*(float) (0x400), -512.0f*(float) (0x100000), (float) (0x80000000U) } } };
|
||||
XMGLOBALCONST XMVECTORF32 g_XMNormalizeA2B10G10R10 = { { { 1.0f / 511.0f, 1.0f / (511.0f*(float) (0x400)), 1.0f / (511.0f*(float) (0x100000)), 1.0f / (3.0f*(float) (0x40000000)) } } };
|
||||
XMGLOBALCONST XMVECTORF32 g_XMFixAA2B10G10R10 = { { { -512.0f, -512.0f*float(0x400), -512.0f*float(0x100000), float(0x80000000U) } } };
|
||||
XMGLOBALCONST XMVECTORF32 g_XMNormalizeA2B10G10R10 = { { { 1.0f / 511.0f, 1.0f / (511.0f*float(0x400)), 1.0f / (511.0f*float(0x100000)), 1.0f / (3.0f*float(0x40000000)) } } };
|
||||
XMGLOBALCONST XMVECTORU32 g_XMMaskX16Y16 = { { { 0x0000FFFF, 0xFFFF0000, 0x00000000, 0x00000000 } } };
|
||||
XMGLOBALCONST XMVECTORI32 g_XMFlipX16Y16 = { { { 0x00008000, 0x00000000, 0x00000000, 0x00000000 } } };
|
||||
XMGLOBALCONST XMVECTORF32 g_XMFixX16Y16 = { { { -32768.0f, 0.0f, 0.0f, 0.0f } } };
|
||||
@ -1979,7 +1979,7 @@ XMGLOBALCONST XMVECTORU32 g_XMFlipW = { { { 0, 0, 0, 0x80000000
|
||||
XMGLOBALCONST XMVECTORU32 g_XMFlipYZ = { { { 0, 0x80000000, 0x80000000, 0 } } };
|
||||
XMGLOBALCONST XMVECTORU32 g_XMFlipZW = { { { 0, 0, 0x80000000, 0x80000000 } } };
|
||||
XMGLOBALCONST XMVECTORU32 g_XMFlipYW = { { { 0, 0x80000000, 0, 0x80000000 } } };
|
||||
XMGLOBALCONST XMVECTORI32 g_XMMaskDec4 = { { { 0x3FF, 0x3FF << 10, 0x3FF << 20, 0x3 << 30 } } };
|
||||
XMGLOBALCONST XMVECTORI32 g_XMMaskDec4 = { { { 0x3FF, 0x3FF << 10, 0x3FF << 20, static_cast<int>(0xC0000000) } } };
|
||||
XMGLOBALCONST XMVECTORI32 g_XMXorDec4 = { { { 0x200, 0x200 << 10, 0x200 << 20, 0 } } };
|
||||
XMGLOBALCONST XMVECTORF32 g_XMAddUDec4 = { { { 0, 0, 0, 32768.0f*65536.0f } } };
|
||||
XMGLOBALCONST XMVECTORF32 g_XMAddDec4 = { { { -512.0f, -512.0f*1024.0f, -512.0f*1024.0f*1024.0f, 0 } } };
|
||||
@ -2067,7 +2067,7 @@ inline XMVECTOR XM_CALLCONV XMVectorSetBinaryConstant(uint32_t C0, uint32_t C1,
|
||||
#else // XM_SSE_INTRINSICS_
|
||||
static const XMVECTORU32 g_vMask1 = { { { 1, 1, 1, 1 } } };
|
||||
// Move the parms to a vector
|
||||
__m128i vTemp = _mm_set_epi32(C3,C2,C1,C0);
|
||||
__m128i vTemp = _mm_set_epi32(static_cast<int>(C3), static_cast<int>(C2), static_cast<int>(C1), static_cast<int>(C0));
|
||||
// Mask off the low bits
|
||||
vTemp = _mm_and_si128(vTemp,g_vMask1);
|
||||
// 0xFFFFFFFF on true bits
|
||||
@ -2099,7 +2099,7 @@ inline XMVECTOR XM_CALLCONV XMVectorSplatConstant(int32_t IntConstant, uint32_t
|
||||
// Convert DivExponent into 1.0f/(1<<DivExponent)
|
||||
uint32_t uScale = 0x3F800000U - (DivExponent << 23);
|
||||
// Splat the scalar value (It's really a float)
|
||||
vScale = vdupq_n_s32(uScale);
|
||||
vScale = vdupq_n_u32(uScale);
|
||||
// Multiply by the reciprocal (Perform a right shift by DivExponent)
|
||||
vResult = vmulq_f32(vResult,reinterpret_cast<const float32x4_t *>(&vScale)[0]);
|
||||
return vResult;
|
||||
@ -2111,7 +2111,7 @@ inline XMVECTOR XM_CALLCONV XMVectorSplatConstant(int32_t IntConstant, uint32_t
|
||||
// Convert DivExponent into 1.0f/(1<<DivExponent)
|
||||
uint32_t uScale = 0x3F800000U - (DivExponent << 23);
|
||||
// Splat the scalar value (It's really a float)
|
||||
vScale = _mm_set1_epi32(uScale);
|
||||
vScale = _mm_set1_epi32(static_cast<int>(uScale));
|
||||
// Multiply by the reciprocal (Perform a right shift by DivExponent)
|
||||
vResult = _mm_mul_ps(vResult,_mm_castsi128_ps(vScale));
|
||||
return vResult;
|
||||
|
||||
@ -29,12 +29,12 @@ inline XMVECTOR XM_CALLCONV XMConvertVectorIntToFloat
|
||||
{
|
||||
assert(DivExponent<32);
|
||||
#if defined(_XM_NO_INTRINSICS_)
|
||||
float fScale = 1.0f / (float)(1U << DivExponent);
|
||||
float fScale = 1.0f / static_cast<float>(1U << DivExponent);
|
||||
uint32_t ElementIndex = 0;
|
||||
XMVECTOR Result;
|
||||
do {
|
||||
int32_t iTemp = (int32_t)VInt.vector4_u32[ElementIndex];
|
||||
Result.vector4_f32[ElementIndex] = ((float)iTemp) * fScale;
|
||||
auto iTemp = static_cast<int32_t>(VInt.vector4_u32[ElementIndex]);
|
||||
Result.vector4_f32[ElementIndex] = static_cast<float>(iTemp) * fScale;
|
||||
} while (++ElementIndex<4);
|
||||
return Result;
|
||||
#elif defined(_XM_ARM_NEON_INTRINSICS_)
|
||||
@ -47,7 +47,7 @@ inline XMVECTOR XM_CALLCONV XMConvertVectorIntToFloat
|
||||
// Convert DivExponent into 1.0f/(1<<DivExponent)
|
||||
uint32_t uScale = 0x3F800000U - (DivExponent << 23);
|
||||
// Splat the scalar value
|
||||
__m128i vScale = _mm_set1_epi32(uScale);
|
||||
__m128i vScale = _mm_set1_epi32(static_cast<int>(uScale));
|
||||
vResult = _mm_mul_ps(vResult,_mm_castsi128_ps(vScale));
|
||||
return vResult;
|
||||
#endif
|
||||
@ -64,7 +64,7 @@ inline XMVECTOR XM_CALLCONV XMConvertVectorFloatToInt
|
||||
assert(MulExponent<32);
|
||||
#if defined(_XM_NO_INTRINSICS_)
|
||||
// Get the scalar factor.
|
||||
float fScale = (float)(1U << MulExponent);
|
||||
auto fScale = static_cast<float>(1U << MulExponent);
|
||||
uint32_t ElementIndex = 0;
|
||||
XMVECTOR Result;
|
||||
do {
|
||||
@ -75,9 +75,9 @@ inline XMVECTOR XM_CALLCONV XMConvertVectorFloatToInt
|
||||
} else if (fTemp > (65536.0f*32768.0f)-128.0f) {
|
||||
iResult = 0x7FFFFFFF;
|
||||
} else {
|
||||
iResult = (int32_t)fTemp;
|
||||
iResult = static_cast<int32_t>(fTemp);
|
||||
}
|
||||
Result.vector4_u32[ElementIndex] = (uint32_t)iResult;
|
||||
Result.vector4_u32[ElementIndex] = static_cast<uint32_t>(iResult);
|
||||
} while (++ElementIndex<4);
|
||||
return Result;
|
||||
#elif defined(_XM_ARM_NEON_INTRINSICS_)
|
||||
@ -92,7 +92,7 @@ inline XMVECTOR XM_CALLCONV XMConvertVectorFloatToInt
|
||||
vOverflow = vorrq_u32(vOverflow,vResult);
|
||||
return vOverflow;
|
||||
#else // _XM_SSE_INTRINSICS_
|
||||
XMVECTOR vResult = _mm_set_ps1((float)(1U << MulExponent));
|
||||
XMVECTOR vResult = _mm_set_ps1(static_cast<float>(1U << MulExponent));
|
||||
vResult = _mm_mul_ps(vResult,VFloat);
|
||||
// In case of positive overflow, detect it
|
||||
XMVECTOR vOverflow = _mm_cmpgt_ps(vResult,g_XMMaxInt);
|
||||
@ -116,11 +116,11 @@ inline XMVECTOR XM_CALLCONV XMConvertVectorUIntToFloat
|
||||
{
|
||||
assert(DivExponent<32);
|
||||
#if defined(_XM_NO_INTRINSICS_)
|
||||
float fScale = 1.0f / (float)(1U << DivExponent);
|
||||
float fScale = 1.0f / static_cast<float>(1U << DivExponent);
|
||||
uint32_t ElementIndex = 0;
|
||||
XMVECTOR Result;
|
||||
do {
|
||||
Result.vector4_f32[ElementIndex] = (float)VUInt.vector4_u32[ElementIndex] * fScale;
|
||||
Result.vector4_f32[ElementIndex] = static_cast<float>(VUInt.vector4_u32[ElementIndex]) * fScale;
|
||||
} while (++ElementIndex<4);
|
||||
return Result;
|
||||
#elif defined(_XM_ARM_NEON_INTRINSICS_)
|
||||
@ -143,7 +143,7 @@ inline XMVECTOR XM_CALLCONV XMConvertVectorUIntToFloat
|
||||
// Convert DivExponent into 1.0f/(1<<DivExponent)
|
||||
uint32_t uScale = 0x3F800000U - (DivExponent << 23);
|
||||
// Splat
|
||||
iMask = _mm_set1_epi32(uScale);
|
||||
iMask = _mm_set1_epi32(static_cast<int>(uScale));
|
||||
vResult = _mm_mul_ps(vResult,_mm_castsi128_ps(iMask));
|
||||
return vResult;
|
||||
#endif
|
||||
@ -160,7 +160,7 @@ inline XMVECTOR XM_CALLCONV XMConvertVectorFloatToUInt
|
||||
assert(MulExponent<32);
|
||||
#if defined(_XM_NO_INTRINSICS_)
|
||||
// Get the scalar factor.
|
||||
float fScale = (float)(1U << MulExponent);
|
||||
auto fScale = static_cast<float>(1U << MulExponent);
|
||||
uint32_t ElementIndex = 0;
|
||||
XMVECTOR Result;
|
||||
do {
|
||||
@ -171,7 +171,7 @@ inline XMVECTOR XM_CALLCONV XMConvertVectorFloatToUInt
|
||||
} else if (fTemp >= (65536.0f*65536.0f)) {
|
||||
uResult = 0xFFFFFFFFU;
|
||||
} else {
|
||||
uResult = (uint32_t)fTemp;
|
||||
uResult = static_cast<uint32_t>(fTemp);
|
||||
}
|
||||
Result.vector4_u32[ElementIndex] = uResult;
|
||||
} while (++ElementIndex<4);
|
||||
@ -292,7 +292,7 @@ inline XMVECTOR XM_CALLCONV XMLoadInt2A
|
||||
)
|
||||
{
|
||||
assert(pSource);
|
||||
assert(((uintptr_t)pSource & 0xF) == 0);
|
||||
assert((reinterpret_cast<uintptr_t>(pSource) & 0xF) == 0);
|
||||
#if defined(_XM_NO_INTRINSICS_)
|
||||
XMVECTOR V;
|
||||
V.vector4_u32[0] = pSource[0];
|
||||
@ -344,7 +344,7 @@ inline XMVECTOR XM_CALLCONV XMLoadFloat2A
|
||||
)
|
||||
{
|
||||
assert(pSource);
|
||||
assert(((uintptr_t)pSource & 0xF) == 0);
|
||||
assert((reinterpret_cast<uintptr_t>(pSource) & 0xF) == 0);
|
||||
#if defined(_XM_NO_INTRINSICS_)
|
||||
XMVECTOR V;
|
||||
V.vector4_f32[0] = pSource->x;
|
||||
@ -372,8 +372,8 @@ inline XMVECTOR XM_CALLCONV XMLoadSInt2
|
||||
assert(pSource);
|
||||
#if defined(_XM_NO_INTRINSICS_)
|
||||
XMVECTOR V;
|
||||
V.vector4_f32[0] = (float)pSource->x;
|
||||
V.vector4_f32[1] = (float)pSource->y;
|
||||
V.vector4_f32[0] = static_cast<float>(pSource->x);
|
||||
V.vector4_f32[1] = static_cast<float>(pSource->y);
|
||||
V.vector4_f32[2] = 0.f;
|
||||
V.vector4_f32[3] = 0.f;
|
||||
return V;
|
||||
@ -400,8 +400,8 @@ inline XMVECTOR XM_CALLCONV XMLoadUInt2
|
||||
assert(pSource);
|
||||
#if defined(_XM_NO_INTRINSICS_)
|
||||
XMVECTOR V;
|
||||
V.vector4_f32[0] = (float)pSource->x;
|
||||
V.vector4_f32[1] = (float)pSource->y;
|
||||
V.vector4_f32[0] = static_cast<float>(pSource->x);
|
||||
V.vector4_f32[1] = static_cast<float>(pSource->y);
|
||||
V.vector4_f32[2] = 0.f;
|
||||
V.vector4_f32[3] = 0.f;
|
||||
return V;
|
||||
@ -467,7 +467,7 @@ inline XMVECTOR XM_CALLCONV XMLoadInt3A
|
||||
)
|
||||
{
|
||||
assert(pSource);
|
||||
assert(((uintptr_t)pSource & 0xF) == 0);
|
||||
assert((reinterpret_cast<uintptr_t>(pSource) & 0xF) == 0);
|
||||
#if defined(_XM_NO_INTRINSICS_)
|
||||
XMVECTOR V;
|
||||
V.vector4_u32[0] = pSource[0];
|
||||
@ -524,7 +524,7 @@ inline XMVECTOR XM_CALLCONV XMLoadFloat3A
|
||||
)
|
||||
{
|
||||
assert(pSource);
|
||||
assert(((uintptr_t)pSource & 0xF) == 0);
|
||||
assert((reinterpret_cast<uintptr_t>(pSource) & 0xF) == 0);
|
||||
#if defined(_XM_NO_INTRINSICS_)
|
||||
XMVECTOR V;
|
||||
V.vector4_f32[0] = pSource->x;
|
||||
@ -554,9 +554,9 @@ inline XMVECTOR XM_CALLCONV XMLoadSInt3
|
||||
#if defined(_XM_NO_INTRINSICS_)
|
||||
|
||||
XMVECTOR V;
|
||||
V.vector4_f32[0] = (float)pSource->x;
|
||||
V.vector4_f32[1] = (float)pSource->y;
|
||||
V.vector4_f32[2] = (float)pSource->z;
|
||||
V.vector4_f32[0] = static_cast<float>(pSource->x);
|
||||
V.vector4_f32[1] = static_cast<float>(pSource->y);
|
||||
V.vector4_f32[2] = static_cast<float>(pSource->z);
|
||||
V.vector4_f32[3] = 0.f;
|
||||
return V;
|
||||
|
||||
@ -586,9 +586,9 @@ inline XMVECTOR XM_CALLCONV XMLoadUInt3
|
||||
assert(pSource);
|
||||
#if defined(_XM_NO_INTRINSICS_)
|
||||
XMVECTOR V;
|
||||
V.vector4_f32[0] = (float)pSource->x;
|
||||
V.vector4_f32[1] = (float)pSource->y;
|
||||
V.vector4_f32[2] = (float)pSource->z;
|
||||
V.vector4_f32[0] = static_cast<float>(pSource->x);
|
||||
V.vector4_f32[1] = static_cast<float>(pSource->y);
|
||||
V.vector4_f32[2] = static_cast<float>(pSource->z);
|
||||
V.vector4_f32[3] = 0.f;
|
||||
return V;
|
||||
#elif defined(_XM_ARM_NEON_INTRINSICS_)
|
||||
@ -651,7 +651,7 @@ inline XMVECTOR XM_CALLCONV XMLoadInt4A
|
||||
)
|
||||
{
|
||||
assert(pSource);
|
||||
assert(((uintptr_t)pSource & 0xF) == 0);
|
||||
assert((reinterpret_cast<uintptr_t>(pSource) & 0xF) == 0);
|
||||
#if defined(_XM_NO_INTRINSICS_)
|
||||
XMVECTOR V;
|
||||
V.vector4_u32[0] = pSource[0];
|
||||
@ -697,7 +697,7 @@ inline XMVECTOR XM_CALLCONV XMLoadFloat4A
|
||||
)
|
||||
{
|
||||
assert(pSource);
|
||||
assert(((uintptr_t)pSource & 0xF) == 0);
|
||||
assert((reinterpret_cast<uintptr_t>(pSource) & 0xF) == 0);
|
||||
#if defined(_XM_NO_INTRINSICS_)
|
||||
XMVECTOR V;
|
||||
V.vector4_f32[0] = pSource->x;
|
||||
@ -723,10 +723,10 @@ inline XMVECTOR XM_CALLCONV XMLoadSInt4
|
||||
#if defined(_XM_NO_INTRINSICS_)
|
||||
|
||||
XMVECTOR V;
|
||||
V.vector4_f32[0] = (float)pSource->x;
|
||||
V.vector4_f32[1] = (float)pSource->y;
|
||||
V.vector4_f32[2] = (float)pSource->z;
|
||||
V.vector4_f32[3] = (float)pSource->w;
|
||||
V.vector4_f32[0] = static_cast<float>(pSource->x);
|
||||
V.vector4_f32[1] = static_cast<float>(pSource->y);
|
||||
V.vector4_f32[2] = static_cast<float>(pSource->z);
|
||||
V.vector4_f32[3] = static_cast<float>(pSource->w);
|
||||
return V;
|
||||
|
||||
#elif defined(_XM_ARM_NEON_INTRINSICS_)
|
||||
@ -748,10 +748,10 @@ inline XMVECTOR XM_CALLCONV XMLoadUInt4
|
||||
assert(pSource);
|
||||
#if defined(_XM_NO_INTRINSICS_)
|
||||
XMVECTOR V;
|
||||
V.vector4_f32[0] = (float)pSource->x;
|
||||
V.vector4_f32[1] = (float)pSource->y;
|
||||
V.vector4_f32[2] = (float)pSource->z;
|
||||
V.vector4_f32[3] = (float)pSource->w;
|
||||
V.vector4_f32[0] = static_cast<float>(pSource->x);
|
||||
V.vector4_f32[1] = static_cast<float>(pSource->y);
|
||||
V.vector4_f32[2] = static_cast<float>(pSource->z);
|
||||
V.vector4_f32[3] = static_cast<float>(pSource->w);
|
||||
return V;
|
||||
#elif defined(_XM_ARM_NEON_INTRINSICS_)
|
||||
uint32x4_t v = vld1q_u32( reinterpret_cast<const uint32_t*>(pSource) );
|
||||
@ -808,7 +808,7 @@ inline XMMATRIX XM_CALLCONV XMLoadFloat3x3
|
||||
#elif defined(_XM_ARM_NEON_INTRINSICS_)
|
||||
float32x4_t v0 = vld1q_f32( &pSource->m[0][0] );
|
||||
float32x4_t v1 = vld1q_f32( &pSource->m[1][1] );
|
||||
float32x2_t v2 = vcreate_f32( (uint64_t)*(const uint32_t*)&pSource->m[2][2] );
|
||||
float32x2_t v2 = vcreate_f32(static_cast<uint64_t>(*reinterpret_cast<const uint32_t*>(&pSource->m[2][2])));
|
||||
float32x4_t T = vextq_f32( v0, v1, 3 );
|
||||
|
||||
XMMATRIX M;
|
||||
@ -927,7 +927,7 @@ inline XMMATRIX XM_CALLCONV XMLoadFloat4x3A
|
||||
)
|
||||
{
|
||||
assert(pSource);
|
||||
assert(((uintptr_t)pSource & 0xF) == 0);
|
||||
assert((reinterpret_cast<uintptr_t>(pSource) & 0xF) == 0);
|
||||
#if defined(_XM_NO_INTRINSICS_)
|
||||
|
||||
XMMATRIX M;
|
||||
@ -1089,7 +1089,7 @@ inline XMMATRIX XM_CALLCONV XMLoadFloat3x4A
|
||||
)
|
||||
{
|
||||
assert(pSource);
|
||||
assert(((uintptr_t)pSource & 0xF) == 0);
|
||||
assert((reinterpret_cast<uintptr_t>(pSource) & 0xF) == 0);
|
||||
#if defined(_XM_NO_INTRINSICS_)
|
||||
|
||||
XMMATRIX M;
|
||||
@ -1220,7 +1220,7 @@ inline XMMATRIX XM_CALLCONV XMLoadFloat4x4A
|
||||
)
|
||||
{
|
||||
assert(pSource);
|
||||
assert(((uintptr_t)pSource & 0xF) == 0);
|
||||
assert((reinterpret_cast<uintptr_t>(pSource) & 0xF) == 0);
|
||||
#if defined(_XM_NO_INTRINSICS_)
|
||||
|
||||
XMMATRIX M;
|
||||
@ -1333,7 +1333,7 @@ inline void XM_CALLCONV XMStoreInt2A
|
||||
)
|
||||
{
|
||||
assert(pDestination);
|
||||
assert(((uintptr_t)pDestination & 0xF) == 0);
|
||||
assert((reinterpret_cast<uintptr_t>(pDestination) & 0xF) == 0);
|
||||
#if defined(_XM_NO_INTRINSICS_)
|
||||
pDestination[0] = V.vector4_u32[0];
|
||||
pDestination[1] = V.vector4_u32[1];
|
||||
@ -1376,7 +1376,7 @@ inline void XM_CALLCONV XMStoreFloat2A
|
||||
)
|
||||
{
|
||||
assert(pDestination);
|
||||
assert(((uintptr_t)pDestination & 0xF) == 0);
|
||||
assert((reinterpret_cast<uintptr_t>(pDestination) & 0xF) == 0);
|
||||
#if defined(_XM_NO_INTRINSICS_)
|
||||
pDestination->x = V.vector4_f32[0];
|
||||
pDestination->y = V.vector4_f32[1];
|
||||
@ -1398,8 +1398,8 @@ inline void XM_CALLCONV XMStoreSInt2
|
||||
{
|
||||
assert(pDestination);
|
||||
#if defined(_XM_NO_INTRINSICS_)
|
||||
pDestination->x = (int32_t)V.vector4_f32[0];
|
||||
pDestination->y = (int32_t)V.vector4_f32[1];
|
||||
pDestination->x = static_cast<int32_t>(V.vector4_f32[0]);
|
||||
pDestination->y = static_cast<int32_t>(V.vector4_f32[1]);
|
||||
#elif defined(_XM_ARM_NEON_INTRINSICS_)
|
||||
int32x2_t v = vget_low_s32(V);
|
||||
v = vcvt_s32_f32( v );
|
||||
@ -1430,8 +1430,8 @@ inline void XM_CALLCONV XMStoreUInt2
|
||||
{
|
||||
assert(pDestination);
|
||||
#if defined(_XM_NO_INTRINSICS_)
|
||||
pDestination->x = (uint32_t)V.vector4_f32[0];
|
||||
pDestination->y = (uint32_t)V.vector4_f32[1];
|
||||
pDestination->x = static_cast<uint32_t>(V.vector4_f32[0]);
|
||||
pDestination->y = static_cast<uint32_t>(V.vector4_f32[1]);
|
||||
#elif defined(_XM_ARM_NEON_INTRINSICS_)
|
||||
float32x2_t v = vget_low_f32(V);
|
||||
uint32x2_t iv = vcvt_u32_f32( v );
|
||||
@ -1496,7 +1496,7 @@ inline void XM_CALLCONV XMStoreInt3A
|
||||
)
|
||||
{
|
||||
assert(pDestination);
|
||||
assert(((uintptr_t)pDestination & 0xF) == 0);
|
||||
assert((reinterpret_cast<uintptr_t>(pDestination) & 0xF) == 0);
|
||||
#if defined(_XM_NO_INTRINSICS_)
|
||||
pDestination[0] = V.vector4_u32[0];
|
||||
pDestination[1] = V.vector4_u32[1];
|
||||
@ -1547,7 +1547,7 @@ inline void XM_CALLCONV XMStoreFloat3A
|
||||
)
|
||||
{
|
||||
assert(pDestination);
|
||||
assert(((uintptr_t)pDestination & 0xF) == 0);
|
||||
assert((reinterpret_cast<uintptr_t>(pDestination) & 0xF) == 0);
|
||||
#if defined(_XM_NO_INTRINSICS_)
|
||||
pDestination->x = V.vector4_f32[0];
|
||||
pDestination->y = V.vector4_f32[1];
|
||||
@ -1573,9 +1573,9 @@ inline void XM_CALLCONV XMStoreSInt3
|
||||
{
|
||||
assert(pDestination);
|
||||
#if defined(_XM_NO_INTRINSICS_)
|
||||
pDestination->x = (int32_t)V.vector4_f32[0];
|
||||
pDestination->y = (int32_t)V.vector4_f32[1];
|
||||
pDestination->z = (int32_t)V.vector4_f32[2];
|
||||
pDestination->x = static_cast<int32_t>(V.vector4_f32[0]);
|
||||
pDestination->y = static_cast<int32_t>(V.vector4_f32[1]);
|
||||
pDestination->z = static_cast<int32_t>(V.vector4_f32[2]);
|
||||
#elif defined(_XM_ARM_NEON_INTRINSICS_)
|
||||
int32x4_t v = vcvtq_s32_f32(V);
|
||||
int32x2_t vL = vget_low_s32(v);
|
||||
@ -1609,9 +1609,9 @@ inline void XM_CALLCONV XMStoreUInt3
|
||||
{
|
||||
assert(pDestination);
|
||||
#if defined(_XM_NO_INTRINSICS_)
|
||||
pDestination->x = (uint32_t)V.vector4_f32[0];
|
||||
pDestination->y = (uint32_t)V.vector4_f32[1];
|
||||
pDestination->z = (uint32_t)V.vector4_f32[2];
|
||||
pDestination->x = static_cast<uint32_t>(V.vector4_f32[0]);
|
||||
pDestination->y = static_cast<uint32_t>(V.vector4_f32[1]);
|
||||
pDestination->z = static_cast<uint32_t>(V.vector4_f32[2]);
|
||||
#elif defined(_XM_ARM_NEON_INTRINSICS_)
|
||||
uint32x4_t v = vcvtq_u32_f32(V);
|
||||
uint32x2_t vL = vget_low_u32(v);
|
||||
@ -1674,7 +1674,7 @@ inline void XM_CALLCONV XMStoreInt4A
|
||||
)
|
||||
{
|
||||
assert(pDestination);
|
||||
assert(((uintptr_t)pDestination & 0xF) == 0);
|
||||
assert((reinterpret_cast<uintptr_t>(pDestination) & 0xF) == 0);
|
||||
#if defined(_XM_NO_INTRINSICS_)
|
||||
pDestination[0] = V.vector4_u32[0];
|
||||
pDestination[1] = V.vector4_u32[1];
|
||||
@ -1717,7 +1717,7 @@ inline void XM_CALLCONV XMStoreFloat4A
|
||||
)
|
||||
{
|
||||
assert(pDestination);
|
||||
assert(((uintptr_t)pDestination & 0xF) == 0);
|
||||
assert((reinterpret_cast<uintptr_t>(pDestination) & 0xF) == 0);
|
||||
#if defined(_XM_NO_INTRINSICS_)
|
||||
pDestination->x = V.vector4_f32[0];
|
||||
pDestination->y = V.vector4_f32[1];
|
||||
@ -1740,10 +1740,10 @@ inline void XM_CALLCONV XMStoreSInt4
|
||||
{
|
||||
assert(pDestination);
|
||||
#if defined(_XM_NO_INTRINSICS_)
|
||||
pDestination->x = (int32_t)V.vector4_f32[0];
|
||||
pDestination->y = (int32_t)V.vector4_f32[1];
|
||||
pDestination->z = (int32_t)V.vector4_f32[2];
|
||||
pDestination->w = (int32_t)V.vector4_f32[3];
|
||||
pDestination->x = static_cast<int32_t>(V.vector4_f32[0]);
|
||||
pDestination->y = static_cast<int32_t>(V.vector4_f32[1]);
|
||||
pDestination->z = static_cast<int32_t>(V.vector4_f32[2]);
|
||||
pDestination->w = static_cast<int32_t>(V.vector4_f32[3]);
|
||||
#elif defined(_XM_ARM_NEON_INTRINSICS_)
|
||||
int32x4_t v = vcvtq_s32_f32(V);
|
||||
vst1q_s32( reinterpret_cast<int32_t*>(pDestination), v );
|
||||
@ -1770,10 +1770,10 @@ inline void XM_CALLCONV XMStoreUInt4
|
||||
{
|
||||
assert(pDestination);
|
||||
#if defined(_XM_NO_INTRINSICS_)
|
||||
pDestination->x = (uint32_t)V.vector4_f32[0];
|
||||
pDestination->y = (uint32_t)V.vector4_f32[1];
|
||||
pDestination->z = (uint32_t)V.vector4_f32[2];
|
||||
pDestination->w = (uint32_t)V.vector4_f32[3];
|
||||
pDestination->x = static_cast<uint32_t>(V.vector4_f32[0]);
|
||||
pDestination->y = static_cast<uint32_t>(V.vector4_f32[1]);
|
||||
pDestination->z = static_cast<uint32_t>(V.vector4_f32[2]);
|
||||
pDestination->w = static_cast<uint32_t>(V.vector4_f32[3]);
|
||||
#elif defined(_XM_ARM_NEON_INTRINSICS_)
|
||||
uint32x4_t v = vcvtq_u32_f32(V);
|
||||
vst1q_u32( reinterpret_cast<uint32_t*>(pDestination), v );
|
||||
@ -1910,7 +1910,7 @@ inline void XM_CALLCONV XMStoreFloat4x3A
|
||||
)
|
||||
{
|
||||
assert(pDestination);
|
||||
assert(((uintptr_t)pDestination & 0xF) == 0);
|
||||
assert((reinterpret_cast<uintptr_t>(pDestination) & 0xF) == 0);
|
||||
#if defined(_XM_NO_INTRINSICS_)
|
||||
|
||||
pDestination->m[0][0] = M.r[0].vector4_f32[0];
|
||||
@ -2035,7 +2035,7 @@ inline void XM_CALLCONV XMStoreFloat3x4A
|
||||
)
|
||||
{
|
||||
assert(pDestination);
|
||||
assert(((uintptr_t)pDestination & 0xF) == 0);
|
||||
assert((reinterpret_cast<uintptr_t>(pDestination) & 0xF) == 0);
|
||||
#if defined(_XM_NO_INTRINSICS_)
|
||||
|
||||
pDestination->m[0][0] = M.r[0].vector4_f32[0];
|
||||
@ -2139,7 +2139,7 @@ inline void XM_CALLCONV XMStoreFloat4x4A
|
||||
)
|
||||
{
|
||||
assert(pDestination);
|
||||
assert(((uintptr_t)pDestination & 0xF) == 0);
|
||||
assert((reinterpret_cast<uintptr_t>(pDestination) & 0xF) == 0);
|
||||
#if defined(_XM_NO_INTRINSICS_)
|
||||
|
||||
pDestination->m[0][0] = M.r[0].vector4_f32[0];
|
||||
|
||||
@ -29,7 +29,7 @@ inline bool XM_CALLCONV XMMatrixIsNaN
|
||||
{
|
||||
#if defined(_XM_NO_INTRINSICS_)
|
||||
size_t i = 16;
|
||||
const uint32_t *pWork = (const uint32_t *)(&M.m[0][0]);
|
||||
auto pWork = reinterpret_cast<const uint32_t *>(&M.m[0][0]);
|
||||
do {
|
||||
// Fetch value into integer unit
|
||||
uint32_t uTest = pWork[0];
|
||||
@ -94,7 +94,7 @@ inline bool XM_CALLCONV XMMatrixIsInfinite
|
||||
{
|
||||
#if defined(_XM_NO_INTRINSICS_)
|
||||
size_t i = 16;
|
||||
const uint32_t *pWork = (const uint32_t *)(&M.m[0][0]);
|
||||
auto pWork = reinterpret_cast<const uint32_t *>(&M.m[0][0]);
|
||||
do {
|
||||
// Fetch value into integer unit
|
||||
uint32_t uTest = pWork[0];
|
||||
@ -157,7 +157,7 @@ inline bool XM_CALLCONV XMMatrixIsIdentity
|
||||
{
|
||||
#if defined(_XM_NO_INTRINSICS_)
|
||||
// Use the integer pipeline to reduce branching to a minimum
|
||||
const uint32_t *pWork = (const uint32_t*)(&M.m[0][0]);
|
||||
auto pWork = reinterpret_cast<const uint32_t*>(&M.m[0][0]);
|
||||
// Convert 1.0f to zero and or them together
|
||||
uint32_t uOne = pWork[0]^0x3F800000U;
|
||||
// Or all the 0.0f entries together
|
||||
@ -995,7 +995,7 @@ inline bool XM_CALLCONV XMMatrixDecompose
|
||||
matTemp.r[2] = M.r[2];
|
||||
matTemp.r[3] = g_XMIdentityR3.v;
|
||||
|
||||
float *pfScales = (float *)outScale;
|
||||
auto pfScales = reinterpret_cast<float *>(outScale);
|
||||
|
||||
size_t a, b, c;
|
||||
XMVectorGetXPtr(&pfScales[0],XMVector3Length(ppvBasis[0][0]));
|
||||
@ -2981,10 +2981,10 @@ inline XMMATRIX::XMMATRIX
|
||||
)
|
||||
{
|
||||
assert( pArray != nullptr );
|
||||
r[0] = XMLoadFloat4((const XMFLOAT4*)pArray);
|
||||
r[1] = XMLoadFloat4((const XMFLOAT4*)(pArray + 4));
|
||||
r[2] = XMLoadFloat4((const XMFLOAT4*)(pArray + 8));
|
||||
r[3] = XMLoadFloat4((const XMFLOAT4*)(pArray + 12));
|
||||
r[0] = XMLoadFloat4(reinterpret_cast<const XMFLOAT4*>(pArray));
|
||||
r[1] = XMLoadFloat4(reinterpret_cast<const XMFLOAT4*>(pArray + 4));
|
||||
r[2] = XMLoadFloat4(reinterpret_cast<const XMFLOAT4*>(pArray + 8));
|
||||
r[3] = XMLoadFloat4(reinterpret_cast<const XMFLOAT4*>(pArray + 12));
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
@ -1124,7 +1124,7 @@ inline XMVECTOR XM_CALLCONV XMPlaneNormalize
|
||||
#if defined(_XM_NO_INTRINSICS_)
|
||||
float fLengthSq = sqrtf((P.vector4_f32[0]*P.vector4_f32[0])+(P.vector4_f32[1]*P.vector4_f32[1])+(P.vector4_f32[2]*P.vector4_f32[2]));
|
||||
// Prevent divide by zero
|
||||
if (fLengthSq)
|
||||
if (fLengthSq > 0)
|
||||
{
|
||||
fLengthSq = 1.0f/fLengthSq;
|
||||
}
|
||||
@ -1748,7 +1748,7 @@ inline XMVECTOR XM_CALLCONV XMColorHSVToRGB( FXMVECTOR hsv )
|
||||
// t = v*(1 - (1-f)*s)
|
||||
XMVECTOR t = XMVectorMultiply( v, XMVectorSubtract( g_XMOne, XMVectorMultiply( XMVectorSubtract( g_XMOne, f ), s ) ) );
|
||||
|
||||
int ii = static_cast<int>( XMVectorGetX( XMVectorMod( i, g_XMSix ) ) );
|
||||
auto ii = static_cast<int>( XMVectorGetX( XMVectorMod( i, g_XMSix ) ) );
|
||||
|
||||
XMVECTOR _rgb;
|
||||
|
||||
@ -2143,7 +2143,7 @@ inline float XMScalarModAngle
|
||||
Angle = Angle + XM_PI;
|
||||
// Perform the modulo, unsigned
|
||||
float fTemp = fabsf(Angle);
|
||||
fTemp = fTemp - (XM_2PI * (float)((int32_t)(fTemp/XM_2PI)));
|
||||
fTemp = fTemp - (XM_2PI * static_cast<float>(static_cast<int32_t>(fTemp/XM_2PI)));
|
||||
// Restore the number to the range of -XM_PI to XM_PI-epsilon
|
||||
fTemp = fTemp - XM_PI;
|
||||
// If the modulo'd value was negative, restore negation
|
||||
@ -2164,11 +2164,11 @@ inline float XMScalarSin
|
||||
float quotient = XM_1DIV2PI*Value;
|
||||
if (Value >= 0.0f)
|
||||
{
|
||||
quotient = (float)((int)(quotient + 0.5f));
|
||||
quotient = static_cast<float>(static_cast<int>(quotient + 0.5f));
|
||||
}
|
||||
else
|
||||
{
|
||||
quotient = (float)((int)(quotient - 0.5f));
|
||||
quotient = static_cast<float>(static_cast<int>(quotient - 0.5f));
|
||||
}
|
||||
float y = Value - XM_2PI*quotient;
|
||||
|
||||
@ -2198,11 +2198,11 @@ inline float XMScalarSinEst
|
||||
float quotient = XM_1DIV2PI*Value;
|
||||
if (Value >= 0.0f)
|
||||
{
|
||||
quotient = (float)((int)(quotient + 0.5f));
|
||||
quotient = static_cast<float>(static_cast<int>(quotient + 0.5f));
|
||||
}
|
||||
else
|
||||
{
|
||||
quotient = (float)((int)(quotient - 0.5f));
|
||||
quotient = static_cast<float>(static_cast<int>(quotient - 0.5f));
|
||||
}
|
||||
float y = Value - XM_2PI*quotient;
|
||||
|
||||
@ -2232,11 +2232,11 @@ inline float XMScalarCos
|
||||
float quotient = XM_1DIV2PI*Value;
|
||||
if (Value >= 0.0f)
|
||||
{
|
||||
quotient = (float)((int)(quotient + 0.5f));
|
||||
quotient = static_cast<float>(static_cast<int>(quotient + 0.5f));
|
||||
}
|
||||
else
|
||||
{
|
||||
quotient = (float)((int)(quotient - 0.5f));
|
||||
quotient = static_cast<float>(static_cast<int>(quotient - 0.5f));
|
||||
}
|
||||
float y = Value - XM_2PI*quotient;
|
||||
|
||||
@ -2274,11 +2274,11 @@ inline float XMScalarCosEst
|
||||
float quotient = XM_1DIV2PI*Value;
|
||||
if (Value >= 0.0f)
|
||||
{
|
||||
quotient = (float)((int)(quotient + 0.5f));
|
||||
quotient = static_cast<float>(static_cast<int>(quotient + 0.5f));
|
||||
}
|
||||
else
|
||||
{
|
||||
quotient = (float)((int)(quotient - 0.5f));
|
||||
quotient = static_cast<float>(static_cast<int>(quotient - 0.5f));
|
||||
}
|
||||
float y = Value - XM_2PI*quotient;
|
||||
|
||||
@ -2322,11 +2322,11 @@ inline void XMScalarSinCos
|
||||
float quotient = XM_1DIV2PI*Value;
|
||||
if (Value >= 0.0f)
|
||||
{
|
||||
quotient = (float)((int)(quotient + 0.5f));
|
||||
quotient = static_cast<float>(static_cast<int>(quotient + 0.5f));
|
||||
}
|
||||
else
|
||||
{
|
||||
quotient = (float)((int)(quotient - 0.5f));
|
||||
quotient = static_cast<float>(static_cast<int>(quotient - 0.5f));
|
||||
}
|
||||
float y = Value - XM_2PI*quotient;
|
||||
|
||||
@ -2374,11 +2374,11 @@ inline void XMScalarSinCosEst
|
||||
float quotient = XM_1DIV2PI*Value;
|
||||
if (Value >= 0.0f)
|
||||
{
|
||||
quotient = (float)((int)(quotient + 0.5f));
|
||||
quotient = static_cast<float>(static_cast<int>(quotient + 0.5f));
|
||||
}
|
||||
else
|
||||
{
|
||||
quotient = (float)((int)(quotient - 0.5f));
|
||||
quotient = static_cast<float>(static_cast<int>(quotient - 0.5f));
|
||||
}
|
||||
float y = Value - XM_2PI*quotient;
|
||||
|
||||
|
||||
@ -10,8 +10,8 @@
|
||||
#pragma once
|
||||
|
||||
#if defined(_XM_NO_INTRINSICS_)
|
||||
#define XMISNAN(x) ((*(const uint32_t*)&(x) & 0x7F800000) == 0x7F800000 && (*(const uint32_t*)&(x) & 0x7FFFFF) != 0)
|
||||
#define XMISINF(x) ((*(const uint32_t*)&(x) & 0x7FFFFFFF) == 0x7F800000)
|
||||
#define XMISNAN(x) isnan(x)
|
||||
#define XMISINF(x) isinf(x)
|
||||
#endif
|
||||
|
||||
#if defined(_XM_SSE_INTRINSICS_)
|
||||
@ -69,8 +69,12 @@ inline XMVECTOR XM_CALLCONV XMVectorSet
|
||||
XMVECTORF32 vResult = { { { x, y, z, w } } };
|
||||
return vResult.v;
|
||||
#elif defined(_XM_ARM_NEON_INTRINSICS_)
|
||||
float32x2_t V0 = vcreate_f32(((uint64_t)*(const uint32_t *)&x) | ((uint64_t)(*(const uint32_t *)&y) << 32));
|
||||
float32x2_t V1 = vcreate_f32(((uint64_t)*(const uint32_t *)&z) | ((uint64_t)(*(const uint32_t *)&w) << 32));
|
||||
float32x2_t V0 = vcreate_f32(
|
||||
static_cast<uint64_t>(*reinterpret_cast<const uint32_t *>(&x))
|
||||
| (static_cast<uint64_t>(*reinterpret_cast<const uint32_t *>(&y)) << 32));
|
||||
float32x2_t V1 = vcreate_f32(
|
||||
static_cast<uint64_t>(*reinterpret_cast<const uint32_t *>(&z))
|
||||
| (static_cast<uint64_t>(*reinterpret_cast<const uint32_t *>(&w)) << 32));
|
||||
return vcombine_f32(V0, V1);
|
||||
#elif defined(_XM_SSE_INTRINSICS_)
|
||||
return _mm_set_ps( w, z, y, x );
|
||||
@ -91,11 +95,11 @@ inline XMVECTOR XM_CALLCONV XMVectorSetInt
|
||||
XMVECTORU32 vResult = { { { x, y, z, w } } };
|
||||
return vResult.v;
|
||||
#elif defined(_XM_ARM_NEON_INTRINSICS_)
|
||||
uint32x2_t V0 = vcreate_u32(((uint64_t)x) | ((uint64_t)y << 32));
|
||||
uint32x2_t V1 = vcreate_u32(((uint64_t)z) | ((uint64_t)w << 32));
|
||||
uint32x2_t V0 = vcreate_u32(static_cast<uint64_t>(x) | (static_cast<uint64_t>(y) << 32));
|
||||
uint32x2_t V1 = vcreate_u32(static_cast<uint64_t>(z) | (static_cast<uint64_t>(w) << 32));
|
||||
return vcombine_u32(V0, V1);
|
||||
#elif defined(_XM_SSE_INTRINSICS_)
|
||||
__m128i V = _mm_set_epi32( w, z, y, x );
|
||||
__m128i V = _mm_set_epi32(static_cast<int>(w), static_cast<int>(z), static_cast<int>(y), static_cast<int>(x));
|
||||
return _mm_castsi128_ps(V);
|
||||
#endif
|
||||
}
|
||||
@ -163,7 +167,7 @@ inline XMVECTOR XM_CALLCONV XMVectorReplicateInt
|
||||
#elif defined(_XM_ARM_NEON_INTRINSICS_)
|
||||
return vdupq_n_u32( Value );
|
||||
#elif defined(_XM_SSE_INTRINSICS_)
|
||||
__m128i vTemp = _mm_set1_epi32( Value );
|
||||
__m128i vTemp = _mm_set1_epi32(static_cast<int>(Value));
|
||||
return _mm_castsi128_ps(vTemp);
|
||||
#endif
|
||||
}
|
||||
@ -392,7 +396,7 @@ inline XMVECTOR XM_CALLCONV XMVectorSplatSignMask()
|
||||
#elif defined(_XM_ARM_NEON_INTRINSICS_)
|
||||
return vdupq_n_u32(0x80000000U);
|
||||
#elif defined(_XM_SSE_INTRINSICS_)
|
||||
__m128i V = _mm_set1_epi32( 0x80000000 );
|
||||
__m128i V = _mm_set1_epi32(static_cast<int>(0x80000000));
|
||||
return _mm_castsi128_ps(V);
|
||||
#endif
|
||||
}
|
||||
@ -509,7 +513,7 @@ inline void XM_CALLCONV XMVectorGetYPtr(float *y, FXMVECTOR V)
|
||||
#elif defined(_XM_ARM_NEON_INTRINSICS_)
|
||||
vst1q_lane_f32(y,V,1);
|
||||
#elif defined(_XM_SSE4_INTRINSICS_)
|
||||
*((int*)y) = _mm_extract_ps( V, 1 );
|
||||
*(reinterpret_cast<int*>(y)) = _mm_extract_ps( V, 1 );
|
||||
#elif defined(_XM_SSE_INTRINSICS_)
|
||||
XMVECTOR vResult = XM_PERMUTE_PS(V,_MM_SHUFFLE(1,1,1,1));
|
||||
_mm_store_ss(y,vResult);
|
||||
@ -526,7 +530,7 @@ inline void XM_CALLCONV XMVectorGetZPtr(float *z, FXMVECTOR V)
|
||||
#elif defined(_XM_ARM_NEON_INTRINSICS_)
|
||||
vst1q_lane_f32(z,V,2);
|
||||
#elif defined(_XM_SSE4_INTRINSICS_)
|
||||
*((int*)z) = _mm_extract_ps( V, 2 );
|
||||
*(reinterpret_cast<int*>(z)) = _mm_extract_ps( V, 2 );
|
||||
#elif defined(_XM_SSE_INTRINSICS_)
|
||||
XMVECTOR vResult = XM_PERMUTE_PS(V,_MM_SHUFFLE(2,2,2,2));
|
||||
_mm_store_ss(z,vResult);
|
||||
@ -543,7 +547,7 @@ inline void XM_CALLCONV XMVectorGetWPtr(float *w, FXMVECTOR V)
|
||||
#elif defined(_XM_ARM_NEON_INTRINSICS_)
|
||||
vst1q_lane_f32(w,V,3);
|
||||
#elif defined(_XM_SSE4_INTRINSICS_)
|
||||
*((int*)w) = _mm_extract_ps( V, 3 );
|
||||
*(reinterpret_cast<int*>(w)) = _mm_extract_ps( V, 3 );
|
||||
#elif defined(_XM_SSE_INTRINSICS_)
|
||||
XMVECTOR vResult = XM_PERMUTE_PS(V,_MM_SHUFFLE(3,3,3,3));
|
||||
_mm_store_ss(w,vResult);
|
||||
@ -993,7 +997,7 @@ inline XMVECTOR XM_CALLCONV XMVectorSetIntX(FXMVECTOR V, uint32_t x)
|
||||
#elif defined(_XM_ARM_NEON_INTRINSICS_)
|
||||
return vsetq_lane_u32(x,V,0);
|
||||
#elif defined(_XM_SSE_INTRINSICS_)
|
||||
__m128i vTemp = _mm_cvtsi32_si128(x);
|
||||
__m128i vTemp = _mm_cvtsi32_si128(static_cast<int>(x));
|
||||
XMVECTOR vResult = _mm_move_ss(V,_mm_castsi128_ps(vTemp));
|
||||
return vResult;
|
||||
#endif
|
||||
@ -1020,7 +1024,7 @@ inline XMVECTOR XM_CALLCONV XMVectorSetIntY(FXMVECTOR V, uint32_t y)
|
||||
// Swap y and x
|
||||
XMVECTOR vResult = XM_PERMUTE_PS(V,_MM_SHUFFLE(3,2,0,1));
|
||||
// Convert input to vector
|
||||
__m128i vTemp = _mm_cvtsi32_si128(y);
|
||||
__m128i vTemp = _mm_cvtsi32_si128(static_cast<int>(y));
|
||||
// Replace the x component
|
||||
vResult = _mm_move_ss(vResult,_mm_castsi128_ps(vTemp));
|
||||
// Swap y and x again
|
||||
@ -1050,7 +1054,7 @@ inline XMVECTOR XM_CALLCONV XMVectorSetIntZ(FXMVECTOR V, uint32_t z)
|
||||
// Swap z and x
|
||||
XMVECTOR vResult = XM_PERMUTE_PS(V,_MM_SHUFFLE(3,0,1,2));
|
||||
// Convert input to vector
|
||||
__m128i vTemp = _mm_cvtsi32_si128(z);
|
||||
__m128i vTemp = _mm_cvtsi32_si128(static_cast<int>(z));
|
||||
// Replace the x component
|
||||
vResult = _mm_move_ss(vResult,_mm_castsi128_ps(vTemp));
|
||||
// Swap z and x again
|
||||
@ -1080,7 +1084,7 @@ inline XMVECTOR XM_CALLCONV XMVectorSetIntW(FXMVECTOR V, uint32_t w)
|
||||
// Swap w and x
|
||||
XMVECTOR vResult = XM_PERMUTE_PS(V,_MM_SHUFFLE(0,2,1,3));
|
||||
// Convert input to vector
|
||||
__m128i vTemp = _mm_cvtsi32_si128(w);
|
||||
__m128i vTemp = _mm_cvtsi32_si128(static_cast<int>(w));
|
||||
// Replace the x component
|
||||
vResult = _mm_move_ss(vResult,_mm_castsi128_ps(vTemp));
|
||||
// Swap w and x again
|
||||
@ -1248,10 +1252,10 @@ inline XMVECTOR XM_CALLCONV XMVectorSwizzle
|
||||
tbl.val[0] = vget_low_f32(V);
|
||||
tbl.val[1] = vget_high_f32(V);
|
||||
|
||||
uint32x2_t idx = vcreate_u32( ((uint64_t)ControlElement[E0]) | (((uint64_t)ControlElement[E1]) << 32) );
|
||||
uint32x2_t idx = vcreate_u32(static_cast<uint64_t>(ControlElement[E0]) | (static_cast<uint64_t>(ControlElement[E1]) << 32));
|
||||
const uint8x8_t rL = vtbl2_u8( tbl, idx );
|
||||
|
||||
idx = vcreate_u32( ((uint64_t)ControlElement[E2]) | (((uint64_t)ControlElement[E3]) << 32) );
|
||||
idx = vcreate_u32(static_cast<uint64_t>(ControlElement[E2]) | (static_cast<uint64_t>(ControlElement[E3]) << 32));
|
||||
const uint8x8_t rH = vtbl2_u8( tbl, idx );
|
||||
|
||||
return vcombine_f32( rL, rH );
|
||||
@ -1260,10 +1264,10 @@ inline XMVECTOR XM_CALLCONV XMVectorSwizzle
|
||||
__m128i vControl = _mm_loadu_si128( reinterpret_cast<const __m128i *>(&elem[0]) );
|
||||
return _mm_permutevar_ps( V, vControl );
|
||||
#else
|
||||
const uint32_t *aPtr = (const uint32_t* )(&V);
|
||||
auto aPtr = reinterpret_cast<const uint32_t*>(&V);
|
||||
|
||||
XMVECTOR Result;
|
||||
uint32_t *pWork = (uint32_t*)(&Result);
|
||||
auto pWork = reinterpret_cast<uint32_t*>(&Result);
|
||||
|
||||
pWork[0] = aPtr[E0];
|
||||
pWork[1] = aPtr[E1];
|
||||
@ -1307,10 +1311,10 @@ inline XMVECTOR XM_CALLCONV XMVectorPermute
|
||||
tbl.val[2] = vget_low_f32(V2);
|
||||
tbl.val[3] = vget_high_f32(V2);
|
||||
|
||||
uint32x2_t idx = vcreate_u32( ((uint64_t)ControlElement[PermuteX]) | (((uint64_t)ControlElement[PermuteY]) << 32) );
|
||||
uint32x2_t idx = vcreate_u32(static_cast<uint64_t>(ControlElement[PermuteX]) | (static_cast<uint64_t>(ControlElement[PermuteY]) << 32));
|
||||
const uint8x8_t rL = vtbl4_u8( tbl, idx );
|
||||
|
||||
idx = vcreate_u32( ((uint64_t)ControlElement[PermuteZ]) | (((uint64_t)ControlElement[PermuteW]) << 32) );
|
||||
idx = vcreate_u32(static_cast<uint64_t>(ControlElement[PermuteZ]) | (static_cast<uint64_t>(ControlElement[PermuteW]) << 32));
|
||||
const uint8x8_t rH = vtbl4_u8( tbl, idx );
|
||||
|
||||
return vcombine_f32( rL, rH );
|
||||
@ -1333,11 +1337,11 @@ inline XMVECTOR XM_CALLCONV XMVectorPermute
|
||||
#else
|
||||
|
||||
const uint32_t *aPtr[2];
|
||||
aPtr[0] = (const uint32_t* )(&V1);
|
||||
aPtr[1] = (const uint32_t* )(&V2);
|
||||
aPtr[0] = reinterpret_cast<const uint32_t*>(&V1);
|
||||
aPtr[1] = reinterpret_cast<const uint32_t*>(&V2);
|
||||
|
||||
XMVECTOR Result;
|
||||
uint32_t *pWork = (uint32_t*)(&Result);
|
||||
auto pWork = reinterpret_cast<uint32_t*>(&Result);
|
||||
|
||||
const uint32_t i0 = PermuteX & 3;
|
||||
const uint32_t vi0 = PermuteX >> 2;
|
||||
@ -1380,13 +1384,13 @@ inline XMVECTOR XM_CALLCONV XMVectorSelectControl
|
||||
{
|
||||
#if defined(_XM_SSE_INTRINSICS_) && !defined(_XM_NO_INTRINSICS_)
|
||||
// x=Index0,y=Index1,z=Index2,w=Index3
|
||||
__m128i vTemp = _mm_set_epi32(VectorIndex3,VectorIndex2,VectorIndex1,VectorIndex0);
|
||||
__m128i vTemp = _mm_set_epi32(static_cast<int>(VectorIndex3), static_cast<int>(VectorIndex2), static_cast<int>(VectorIndex1), static_cast<int>(VectorIndex0));
|
||||
// Any non-zero entries become 0xFFFFFFFF else 0
|
||||
vTemp = _mm_cmpgt_epi32(vTemp,g_XMZero);
|
||||
return _mm_castsi128_ps(vTemp);
|
||||
#elif defined(_XM_ARM_NEON_INTRINSICS_) && !defined(_XM_NO_INTRINSICS_)
|
||||
int32x2_t V0 = vcreate_s32(((uint64_t)VectorIndex0) | ((uint64_t)VectorIndex1 << 32));
|
||||
int32x2_t V1 = vcreate_s32(((uint64_t)VectorIndex2) | ((uint64_t)VectorIndex3 << 32));
|
||||
int32x2_t V0 = vcreate_s32(static_cast<uint64_t>(VectorIndex0) | (static_cast<uint64_t>(VectorIndex1) << 32));
|
||||
int32x2_t V1 = vcreate_s32(static_cast<uint64_t>(VectorIndex2) | (static_cast<uint64_t>(VectorIndex3) << 32));
|
||||
int32x4_t vTemp = vcombine_s32(V0, V1);
|
||||
// Any non-zero entries become 0xFFFFFFFF else 0
|
||||
return vcgtq_s32(vTemp,g_XMZero);
|
||||
@ -2303,7 +2307,7 @@ namespace Internal
|
||||
|
||||
return i + 1.f;
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
#if !defined(_XM_NO_INTRINSICS_) && !defined(__clang__) && !defined(__INTEL_COMPILER)
|
||||
#pragma float_control(push)
|
||||
@ -2380,7 +2384,7 @@ inline XMVECTOR XM_CALLCONV XMVectorTruncate
|
||||
}
|
||||
else if (fabsf(V.vector4_f32[i]) < 8388608.0f)
|
||||
{
|
||||
Result.vector4_f32[i] = (float)((int32_t)V.vector4_f32[i]);
|
||||
Result.vector4_f32[i] = static_cast<float>(static_cast<int32_t>(V.vector4_f32[i]));
|
||||
}
|
||||
else
|
||||
{
|
||||
@ -4619,7 +4623,7 @@ inline XMVECTOR XM_CALLCONV XMVectorTan
|
||||
#else
|
||||
for (size_t i = 0; i < 4; i++)
|
||||
{
|
||||
VB.vector4_u32[i] = (uint32_t)VB.vector4_f32[i];
|
||||
VB.vector4_u32[i] = static_cast<uint32_t>(VB.vector4_f32[i]);
|
||||
}
|
||||
#endif
|
||||
|
||||
@ -7676,8 +7680,8 @@ inline XMFLOAT4* XM_CALLCONV XMVector2TransformStream
|
||||
|
||||
#if defined(_XM_NO_INTRINSICS_)
|
||||
|
||||
const uint8_t* pInputVector = (const uint8_t*)pInputStream;
|
||||
uint8_t* pOutputVector = (uint8_t*)pOutputStream;
|
||||
auto pInputVector = reinterpret_cast<const uint8_t*>(pInputStream);
|
||||
auto pOutputVector = reinterpret_cast<uint8_t*>(pOutputStream);
|
||||
|
||||
const XMVECTOR row0 = M.r[0];
|
||||
const XMVECTOR row1 = M.r[1];
|
||||
@ -7685,7 +7689,7 @@ inline XMFLOAT4* XM_CALLCONV XMVector2TransformStream
|
||||
|
||||
for (size_t i = 0; i < VectorCount; i++)
|
||||
{
|
||||
XMVECTOR V = XMLoadFloat2((const XMFLOAT2*)pInputVector);
|
||||
XMVECTOR V = XMLoadFloat2(reinterpret_cast<const XMFLOAT2*>(pInputVector));
|
||||
XMVECTOR Y = XMVectorSplatY(V);
|
||||
XMVECTOR X = XMVectorSplatX(V);
|
||||
|
||||
@ -7697,7 +7701,7 @@ inline XMFLOAT4* XM_CALLCONV XMVector2TransformStream
|
||||
#pragma prefast(disable : 26015, "PREfast noise: Esp:1307" )
|
||||
#endif
|
||||
|
||||
XMStoreFloat4((XMFLOAT4*)pOutputVector, Result);
|
||||
XMStoreFloat4(reinterpret_cast<XMFLOAT4*>(pOutputVector), Result);
|
||||
|
||||
#ifdef _PREFAST_
|
||||
#pragma prefast(pop)
|
||||
@ -7710,8 +7714,8 @@ inline XMFLOAT4* XM_CALLCONV XMVector2TransformStream
|
||||
return pOutputStream;
|
||||
|
||||
#elif defined(_XM_ARM_NEON_INTRINSICS_)
|
||||
const uint8_t* pInputVector = (const uint8_t*)pInputStream;
|
||||
uint8_t* pOutputVector = (uint8_t*)pOutputStream;
|
||||
auto pInputVector = reinterpret_cast<const uint8_t*>(pInputStream);
|
||||
auto pOutputVector = reinterpret_cast<uint8_t*>(pOutputStream);
|
||||
|
||||
const XMVECTOR row0 = M.r[0];
|
||||
const XMVECTOR row1 = M.r[1];
|
||||
@ -7782,8 +7786,8 @@ inline XMFLOAT4* XM_CALLCONV XMVector2TransformStream
|
||||
|
||||
return pOutputStream;
|
||||
#elif defined(_XM_SSE_INTRINSICS_)
|
||||
const uint8_t* pInputVector = (const uint8_t*)pInputStream;
|
||||
uint8_t* pOutputVector = (uint8_t*)pOutputStream;
|
||||
auto pInputVector = reinterpret_cast<const uint8_t*>(pInputStream);
|
||||
auto pOutputVector = reinterpret_cast<uint8_t*>(pOutputStream);
|
||||
|
||||
const XMVECTOR row0 = M.r[0];
|
||||
const XMVECTOR row1 = M.r[1];
|
||||
@ -7795,7 +7799,7 @@ inline XMFLOAT4* XM_CALLCONV XMVector2TransformStream
|
||||
{
|
||||
if ( InputStride == sizeof(XMFLOAT2) )
|
||||
{
|
||||
if ( !((uintptr_t)pOutputStream & 0xF) && !(OutputStride & 0xF) )
|
||||
if ( !(reinterpret_cast<uintptr_t>(pOutputStream) & 0xF) && !(OutputStride & 0xF) )
|
||||
{
|
||||
// Packed input, aligned output
|
||||
for (size_t j = 0; j < two; ++j)
|
||||
@ -7864,9 +7868,9 @@ inline XMFLOAT4* XM_CALLCONV XMVector2TransformStream
|
||||
}
|
||||
}
|
||||
|
||||
if ( !((uintptr_t)pInputVector & 0xF) && !(InputStride & 0xF) )
|
||||
if ( !(reinterpret_cast<uintptr_t>(pInputVector) & 0xF) && !(InputStride & 0xF) )
|
||||
{
|
||||
if ( !((uintptr_t)pOutputStream & 0xF) && !(OutputStride & 0xF) )
|
||||
if ( !(reinterpret_cast<uintptr_t>(pOutputStream) & 0xF) && !(OutputStride & 0xF) )
|
||||
{
|
||||
// Aligned input, aligned output
|
||||
for (; i < VectorCount; i++)
|
||||
@ -7977,8 +7981,8 @@ inline XMFLOAT2* XM_CALLCONV XMVector2TransformCoordStream
|
||||
|
||||
#if defined(_XM_NO_INTRINSICS_)
|
||||
|
||||
const uint8_t* pInputVector = (const uint8_t*)pInputStream;
|
||||
uint8_t* pOutputVector = (uint8_t*)pOutputStream;
|
||||
auto pInputVector = reinterpret_cast<const uint8_t*>(pInputStream);
|
||||
auto pOutputVector = reinterpret_cast<uint8_t*>(pOutputStream);
|
||||
|
||||
const XMVECTOR row0 = M.r[0];
|
||||
const XMVECTOR row1 = M.r[1];
|
||||
@ -7986,7 +7990,7 @@ inline XMFLOAT2* XM_CALLCONV XMVector2TransformCoordStream
|
||||
|
||||
for (size_t i = 0; i < VectorCount; i++)
|
||||
{
|
||||
XMVECTOR V = XMLoadFloat2((const XMFLOAT2*)pInputVector);
|
||||
XMVECTOR V = XMLoadFloat2(reinterpret_cast<const XMFLOAT2*>(pInputVector));
|
||||
XMVECTOR Y = XMVectorSplatY(V);
|
||||
XMVECTOR X = XMVectorSplatX(V);
|
||||
|
||||
@ -8002,7 +8006,7 @@ inline XMFLOAT2* XM_CALLCONV XMVector2TransformCoordStream
|
||||
#pragma prefast(disable : 26015, "PREfast noise: Esp:1307" )
|
||||
#endif
|
||||
|
||||
XMStoreFloat2((XMFLOAT2*)pOutputVector, Result);
|
||||
XMStoreFloat2(reinterpret_cast<XMFLOAT2*>(pOutputVector), Result);
|
||||
|
||||
#ifdef _PREFAST_
|
||||
#pragma prefast(pop)
|
||||
@ -8015,8 +8019,8 @@ inline XMFLOAT2* XM_CALLCONV XMVector2TransformCoordStream
|
||||
return pOutputStream;
|
||||
|
||||
#elif defined(_XM_ARM_NEON_INTRINSICS_)
|
||||
const uint8_t* pInputVector = (const uint8_t*)pInputStream;
|
||||
uint8_t* pOutputVector = (uint8_t*)pOutputStream;
|
||||
auto pInputVector = reinterpret_cast<const uint8_t*>(pInputStream);
|
||||
auto pOutputVector = reinterpret_cast<uint8_t*>(pOutputStream);
|
||||
|
||||
const XMVECTOR row0 = M.r[0];
|
||||
const XMVECTOR row1 = M.r[1];
|
||||
@ -8112,8 +8116,8 @@ inline XMFLOAT2* XM_CALLCONV XMVector2TransformCoordStream
|
||||
|
||||
return pOutputStream;
|
||||
#elif defined(_XM_SSE_INTRINSICS_)
|
||||
const uint8_t* pInputVector = (const uint8_t*)pInputStream;
|
||||
uint8_t* pOutputVector = (uint8_t*)pOutputStream;
|
||||
auto pInputVector = reinterpret_cast<const uint8_t*>(pInputStream);
|
||||
auto pOutputVector = reinterpret_cast<uint8_t*>(pOutputStream);
|
||||
|
||||
const XMVECTOR row0 = M.r[0];
|
||||
const XMVECTOR row1 = M.r[1];
|
||||
@ -8127,7 +8131,7 @@ inline XMFLOAT2* XM_CALLCONV XMVector2TransformCoordStream
|
||||
{
|
||||
if ( OutputStride == sizeof(XMFLOAT2) )
|
||||
{
|
||||
if ( !((uintptr_t)pOutputStream & 0xF) )
|
||||
if ( !(reinterpret_cast<uintptr_t>(pOutputStream) & 0xF) )
|
||||
{
|
||||
// Packed input, aligned & packed output
|
||||
for (size_t j = 0; j < two; ++j)
|
||||
@ -8262,7 +8266,7 @@ inline XMFLOAT2* XM_CALLCONV XMVector2TransformCoordStream
|
||||
}
|
||||
}
|
||||
|
||||
if ( !((uintptr_t)pInputVector & 0xF) && !(InputStride & 0xF) )
|
||||
if ( !(reinterpret_cast<uintptr_t>(pInputVector) & 0xF) && !(InputStride & 0xF) )
|
||||
{
|
||||
// Aligned input
|
||||
for (; i < VectorCount; i++)
|
||||
@ -8378,15 +8382,15 @@ inline XMFLOAT2* XM_CALLCONV XMVector2TransformNormalStream
|
||||
|
||||
#if defined(_XM_NO_INTRINSICS_)
|
||||
|
||||
const uint8_t* pInputVector = (const uint8_t*)pInputStream;
|
||||
uint8_t* pOutputVector = (uint8_t*)pOutputStream;
|
||||
auto pInputVector = reinterpret_cast<const uint8_t*>(pInputStream);
|
||||
auto pOutputVector = reinterpret_cast<uint8_t*>(pOutputStream);
|
||||
|
||||
const XMVECTOR row0 = M.r[0];
|
||||
const XMVECTOR row1 = M.r[1];
|
||||
|
||||
for (size_t i = 0; i < VectorCount; i++)
|
||||
{
|
||||
XMVECTOR V = XMLoadFloat2((const XMFLOAT2*)pInputVector);
|
||||
XMVECTOR V = XMLoadFloat2(reinterpret_cast<const XMFLOAT2*>(pInputVector));
|
||||
XMVECTOR Y = XMVectorSplatY(V);
|
||||
XMVECTOR X = XMVectorSplatX(V);
|
||||
|
||||
@ -8398,7 +8402,7 @@ inline XMFLOAT2* XM_CALLCONV XMVector2TransformNormalStream
|
||||
#pragma prefast(disable : 26015, "PREfast noise: Esp:1307" )
|
||||
#endif
|
||||
|
||||
XMStoreFloat2((XMFLOAT2*)pOutputVector, Result);
|
||||
XMStoreFloat2(reinterpret_cast<XMFLOAT2*>(pOutputVector), Result);
|
||||
|
||||
#ifdef _PREFAST_
|
||||
#pragma prefast(pop)
|
||||
@ -8411,8 +8415,8 @@ inline XMFLOAT2* XM_CALLCONV XMVector2TransformNormalStream
|
||||
return pOutputStream;
|
||||
|
||||
#elif defined(_XM_ARM_NEON_INTRINSICS_)
|
||||
const uint8_t* pInputVector = (const uint8_t*)pInputStream;
|
||||
uint8_t* pOutputVector = (uint8_t*)pOutputStream;
|
||||
auto pInputVector = reinterpret_cast<const uint8_t*>(pInputStream);
|
||||
auto pOutputVector = reinterpret_cast<uint8_t*>(pOutputStream);
|
||||
|
||||
const XMVECTOR row0 = M.r[0];
|
||||
const XMVECTOR row1 = M.r[1];
|
||||
@ -8468,8 +8472,8 @@ inline XMFLOAT2* XM_CALLCONV XMVector2TransformNormalStream
|
||||
|
||||
return pOutputStream;
|
||||
#elif defined(_XM_SSE_INTRINSICS_)
|
||||
const uint8_t* pInputVector = (const uint8_t*)pInputStream;
|
||||
uint8_t* pOutputVector = (uint8_t*)pOutputStream;
|
||||
auto pInputVector = reinterpret_cast<const uint8_t*>(pInputStream);
|
||||
auto pOutputVector = reinterpret_cast<uint8_t*>(pOutputStream);
|
||||
|
||||
const XMVECTOR row0 = M.r[0];
|
||||
const XMVECTOR row1 = M.r[1];
|
||||
@ -8482,7 +8486,7 @@ inline XMFLOAT2* XM_CALLCONV XMVector2TransformNormalStream
|
||||
{
|
||||
if ( OutputStride == sizeof(XMFLOAT2) )
|
||||
{
|
||||
if ( !((uintptr_t)pOutputStream & 0xF) )
|
||||
if ( !(reinterpret_cast<uintptr_t>(pOutputStream) & 0xF) )
|
||||
{
|
||||
// Packed input, aligned & packed output
|
||||
for (size_t j = 0; j < two; ++j)
|
||||
@ -8587,7 +8591,7 @@ inline XMFLOAT2* XM_CALLCONV XMVector2TransformNormalStream
|
||||
}
|
||||
}
|
||||
|
||||
if ( !((uintptr_t)pInputVector & 0xF) && !(InputStride & 0xF) )
|
||||
if ( !(reinterpret_cast<uintptr_t>(pInputVector) & 0xF) && !(InputStride & 0xF) )
|
||||
{
|
||||
// Aligned input
|
||||
for (; i < VectorCount; i++)
|
||||
@ -10141,8 +10145,8 @@ inline XMFLOAT4* XM_CALLCONV XMVector3TransformStream
|
||||
|
||||
#if defined(_XM_NO_INTRINSICS_)
|
||||
|
||||
const uint8_t* pInputVector = (const uint8_t*)pInputStream;
|
||||
uint8_t* pOutputVector = (uint8_t*)pOutputStream;
|
||||
auto pInputVector = reinterpret_cast<const uint8_t*>(pInputStream);
|
||||
auto pOutputVector = reinterpret_cast<uint8_t*>(pOutputStream);
|
||||
|
||||
const XMVECTOR row0 = M.r[0];
|
||||
const XMVECTOR row1 = M.r[1];
|
||||
@ -10151,7 +10155,7 @@ inline XMFLOAT4* XM_CALLCONV XMVector3TransformStream
|
||||
|
||||
for (size_t i = 0; i < VectorCount; i++)
|
||||
{
|
||||
XMVECTOR V = XMLoadFloat3((const XMFLOAT3*)pInputVector);
|
||||
XMVECTOR V = XMLoadFloat3(reinterpret_cast<const XMFLOAT3*>(pInputVector));
|
||||
XMVECTOR Z = XMVectorSplatZ(V);
|
||||
XMVECTOR Y = XMVectorSplatY(V);
|
||||
XMVECTOR X = XMVectorSplatX(V);
|
||||
@ -10160,7 +10164,7 @@ inline XMFLOAT4* XM_CALLCONV XMVector3TransformStream
|
||||
Result = XMVectorMultiplyAdd(Y, row1, Result);
|
||||
Result = XMVectorMultiplyAdd(X, row0, Result);
|
||||
|
||||
XMStoreFloat4((XMFLOAT4*)pOutputVector, Result);
|
||||
XMStoreFloat4(reinterpret_cast<XMFLOAT4*>(pOutputVector), Result);
|
||||
|
||||
pInputVector += InputStride;
|
||||
pOutputVector += OutputStride;
|
||||
@ -10169,8 +10173,8 @@ inline XMFLOAT4* XM_CALLCONV XMVector3TransformStream
|
||||
return pOutputStream;
|
||||
|
||||
#elif defined(_XM_ARM_NEON_INTRINSICS_)
|
||||
const uint8_t* pInputVector = (const uint8_t*)pInputStream;
|
||||
uint8_t* pOutputVector = (uint8_t*)pOutputStream;
|
||||
auto pInputVector = reinterpret_cast<const uint8_t*>(pInputStream);
|
||||
auto pOutputVector = reinterpret_cast<uint8_t*>(pOutputStream);
|
||||
|
||||
const XMVECTOR row0 = M.r[0];
|
||||
const XMVECTOR row1 = M.r[1];
|
||||
@ -10257,8 +10261,8 @@ inline XMFLOAT4* XM_CALLCONV XMVector3TransformStream
|
||||
|
||||
return pOutputStream;
|
||||
#elif defined(_XM_SSE_INTRINSICS_)
|
||||
const uint8_t* pInputVector = (const uint8_t*)pInputStream;
|
||||
uint8_t* pOutputVector = (uint8_t*)pOutputStream;
|
||||
auto pInputVector = reinterpret_cast<const uint8_t*>(pInputStream);
|
||||
auto pOutputVector = reinterpret_cast<uint8_t*>(pOutputStream);
|
||||
|
||||
const XMVECTOR row0 = M.r[0];
|
||||
const XMVECTOR row1 = M.r[1];
|
||||
@ -10271,7 +10275,7 @@ inline XMFLOAT4* XM_CALLCONV XMVector3TransformStream
|
||||
{
|
||||
if (InputStride == sizeof(XMFLOAT3))
|
||||
{
|
||||
if ( !((uintptr_t)pOutputStream & 0xF) && !(OutputStride & 0xF) )
|
||||
if ( !(reinterpret_cast<uintptr_t>(pOutputStream) & 0xF) && !(OutputStride & 0xF) )
|
||||
{
|
||||
// Packed input, aligned output
|
||||
for (size_t j = 0; j < four; ++j)
|
||||
@ -10418,7 +10422,7 @@ inline XMFLOAT4* XM_CALLCONV XMVector3TransformStream
|
||||
}
|
||||
}
|
||||
|
||||
if ( !((uintptr_t)pOutputStream & 0xF) && !(OutputStride & 0xF) )
|
||||
if ( !(reinterpret_cast<uintptr_t>(pOutputStream) & 0xF) && !(OutputStride & 0xF) )
|
||||
{
|
||||
// Aligned output
|
||||
for (; i < VectorCount; ++i)
|
||||
@ -10524,8 +10528,8 @@ inline XMFLOAT3* XM_CALLCONV XMVector3TransformCoordStream
|
||||
|
||||
#if defined(_XM_NO_INTRINSICS_)
|
||||
|
||||
const uint8_t* pInputVector = (const uint8_t*)pInputStream;
|
||||
uint8_t* pOutputVector = (uint8_t*)pOutputStream;
|
||||
auto pInputVector = reinterpret_cast<const uint8_t*>(pInputStream);
|
||||
auto pOutputVector = reinterpret_cast<uint8_t*>(pOutputStream);
|
||||
|
||||
const XMVECTOR row0 = M.r[0];
|
||||
const XMVECTOR row1 = M.r[1];
|
||||
@ -10534,7 +10538,7 @@ inline XMFLOAT3* XM_CALLCONV XMVector3TransformCoordStream
|
||||
|
||||
for (size_t i = 0; i < VectorCount; i++)
|
||||
{
|
||||
XMVECTOR V = XMLoadFloat3((const XMFLOAT3*)pInputVector);
|
||||
XMVECTOR V = XMLoadFloat3(reinterpret_cast<const XMFLOAT3*>(pInputVector));
|
||||
XMVECTOR Z = XMVectorSplatZ(V);
|
||||
XMVECTOR Y = XMVectorSplatY(V);
|
||||
XMVECTOR X = XMVectorSplatX(V);
|
||||
@ -10547,7 +10551,7 @@ inline XMFLOAT3* XM_CALLCONV XMVector3TransformCoordStream
|
||||
|
||||
Result = XMVectorDivide(Result, W);
|
||||
|
||||
XMStoreFloat3((XMFLOAT3*)pOutputVector, Result);
|
||||
XMStoreFloat3(reinterpret_cast<XMFLOAT3*>(pOutputVector), Result);
|
||||
|
||||
pInputVector += InputStride;
|
||||
pOutputVector += OutputStride;
|
||||
@ -10556,8 +10560,8 @@ inline XMFLOAT3* XM_CALLCONV XMVector3TransformCoordStream
|
||||
return pOutputStream;
|
||||
|
||||
#elif defined(_XM_ARM_NEON_INTRINSICS_)
|
||||
const uint8_t* pInputVector = (const uint8_t*)pInputStream;
|
||||
uint8_t* pOutputVector = (uint8_t*)pOutputStream;
|
||||
auto pInputVector = reinterpret_cast<const uint8_t*>(pInputStream);
|
||||
auto pOutputVector = reinterpret_cast<uint8_t*>(pOutputStream);
|
||||
|
||||
const XMVECTOR row0 = M.r[0];
|
||||
const XMVECTOR row1 = M.r[1];
|
||||
@ -10673,8 +10677,8 @@ inline XMFLOAT3* XM_CALLCONV XMVector3TransformCoordStream
|
||||
|
||||
return pOutputStream;
|
||||
#elif defined(_XM_SSE_INTRINSICS_)
|
||||
const uint8_t* pInputVector = (const uint8_t*)pInputStream;
|
||||
uint8_t* pOutputVector = (uint8_t*)pOutputStream;
|
||||
auto pInputVector = reinterpret_cast<const uint8_t*>(pInputStream);
|
||||
auto pOutputVector = reinterpret_cast<uint8_t*>(pOutputStream);
|
||||
|
||||
const XMVECTOR row0 = M.r[0];
|
||||
const XMVECTOR row1 = M.r[1];
|
||||
@ -10689,7 +10693,7 @@ inline XMFLOAT3* XM_CALLCONV XMVector3TransformCoordStream
|
||||
{
|
||||
if (OutputStride == sizeof(XMFLOAT3))
|
||||
{
|
||||
if ( !((uintptr_t)pOutputStream & 0xF) )
|
||||
if ( !(reinterpret_cast<uintptr_t>(pOutputStream) & 0xF) )
|
||||
{
|
||||
// Packed input, aligned & packed output
|
||||
for (size_t j = 0; j < four; ++j)
|
||||
@ -11054,8 +11058,8 @@ inline XMFLOAT3* XM_CALLCONV XMVector3TransformNormalStream
|
||||
|
||||
#if defined(_XM_NO_INTRINSICS_)
|
||||
|
||||
const uint8_t* pInputVector = (const uint8_t*)pInputStream;
|
||||
uint8_t* pOutputVector = (uint8_t*)pOutputStream;
|
||||
auto pInputVector = reinterpret_cast<const uint8_t*>(pInputStream);
|
||||
auto pOutputVector = reinterpret_cast<uint8_t*>(pOutputStream);
|
||||
|
||||
const XMVECTOR row0 = M.r[0];
|
||||
const XMVECTOR row1 = M.r[1];
|
||||
@ -11063,7 +11067,7 @@ inline XMFLOAT3* XM_CALLCONV XMVector3TransformNormalStream
|
||||
|
||||
for (size_t i = 0; i < VectorCount; i++)
|
||||
{
|
||||
XMVECTOR V = XMLoadFloat3((const XMFLOAT3*)pInputVector);
|
||||
XMVECTOR V = XMLoadFloat3(reinterpret_cast<const XMFLOAT3*>(pInputVector));
|
||||
XMVECTOR Z = XMVectorSplatZ(V);
|
||||
XMVECTOR Y = XMVectorSplatY(V);
|
||||
XMVECTOR X = XMVectorSplatX(V);
|
||||
@ -11072,7 +11076,7 @@ inline XMFLOAT3* XM_CALLCONV XMVector3TransformNormalStream
|
||||
Result = XMVectorMultiplyAdd(Y, row1, Result);
|
||||
Result = XMVectorMultiplyAdd(X, row0, Result);
|
||||
|
||||
XMStoreFloat3((XMFLOAT3*)pOutputVector, Result);
|
||||
XMStoreFloat3(reinterpret_cast<XMFLOAT3*>(pOutputVector), Result);
|
||||
|
||||
pInputVector += InputStride;
|
||||
pOutputVector += OutputStride;
|
||||
@ -11081,8 +11085,8 @@ inline XMFLOAT3* XM_CALLCONV XMVector3TransformNormalStream
|
||||
return pOutputStream;
|
||||
|
||||
#elif defined(_XM_ARM_NEON_INTRINSICS_)
|
||||
const uint8_t* pInputVector = (const uint8_t*)pInputStream;
|
||||
uint8_t* pOutputVector = (uint8_t*)pOutputStream;
|
||||
auto pInputVector = reinterpret_cast<const uint8_t*>(pInputStream);
|
||||
auto pOutputVector = reinterpret_cast<uint8_t*>(pOutputStream);
|
||||
|
||||
const XMVECTOR row0 = M.r[0];
|
||||
const XMVECTOR row1 = M.r[1];
|
||||
@ -11163,8 +11167,8 @@ inline XMFLOAT3* XM_CALLCONV XMVector3TransformNormalStream
|
||||
|
||||
return pOutputStream;
|
||||
#elif defined(_XM_SSE_INTRINSICS_)
|
||||
const uint8_t* pInputVector = (const uint8_t*)pInputStream;
|
||||
uint8_t* pOutputVector = (uint8_t*)pOutputStream;
|
||||
auto pInputVector = reinterpret_cast<const uint8_t*>(pInputStream);
|
||||
auto pOutputVector = reinterpret_cast<uint8_t*>(pOutputStream);
|
||||
|
||||
const XMVECTOR row0 = M.r[0];
|
||||
const XMVECTOR row1 = M.r[1];
|
||||
@ -11178,7 +11182,7 @@ inline XMFLOAT3* XM_CALLCONV XMVector3TransformNormalStream
|
||||
{
|
||||
if (OutputStride == sizeof(XMFLOAT3))
|
||||
{
|
||||
if ( !((uintptr_t)pOutputStream & 0xF) )
|
||||
if ( !(reinterpret_cast<uintptr_t>(pOutputStream) & 0xF) )
|
||||
{
|
||||
// Packed input, aligned & packed output
|
||||
for (size_t j = 0; j < four; ++j)
|
||||
@ -11493,17 +11497,17 @@ inline XMFLOAT3* XM_CALLCONV XMVector3ProjectStream
|
||||
XMMATRIX Transform = XMMatrixMultiply(World, View);
|
||||
Transform = XMMatrixMultiply(Transform, Projection);
|
||||
|
||||
const uint8_t* pInputVector = (const uint8_t*)pInputStream;
|
||||
uint8_t* pOutputVector = (uint8_t*)pOutputStream;
|
||||
auto pInputVector = reinterpret_cast<const uint8_t*>(pInputStream);
|
||||
auto pOutputVector = reinterpret_cast<uint8_t*>(pOutputStream);
|
||||
|
||||
for (size_t i = 0; i < VectorCount; i++)
|
||||
{
|
||||
XMVECTOR V = XMLoadFloat3((const XMFLOAT3*)pInputVector);
|
||||
XMVECTOR V = XMLoadFloat3(reinterpret_cast<const XMFLOAT3*>(pInputVector));
|
||||
|
||||
XMVECTOR Result = XMVector3TransformCoord(V, Transform);
|
||||
Result = XMVectorMultiplyAdd(Result, Scale, Offset);
|
||||
|
||||
XMStoreFloat3((XMFLOAT3*)pOutputVector, Result);
|
||||
XMStoreFloat3(reinterpret_cast<XMFLOAT3*>(pOutputVector), Result);
|
||||
|
||||
pInputVector += InputStride;
|
||||
pOutputVector += OutputStride;
|
||||
@ -11517,8 +11521,9 @@ inline XMFLOAT3* XM_CALLCONV XMVector3ProjectStream
|
||||
|
||||
XMMATRIX Transform = XMMatrixMultiply(World, View);
|
||||
Transform = XMMatrixMultiply(Transform, Projection);
|
||||
const uint8_t* pInputVector = (const uint8_t*)pInputStream;
|
||||
uint8_t* pOutputVector = (uint8_t*)pOutputStream;
|
||||
|
||||
auto pInputVector = reinterpret_cast<const uint8_t*>(pInputStream);
|
||||
auto pOutputVector = reinterpret_cast<uint8_t*>(pOutputStream);
|
||||
|
||||
size_t i = 0;
|
||||
size_t four = VectorCount >> 2;
|
||||
@ -11658,8 +11663,8 @@ inline XMFLOAT3* XM_CALLCONV XMVector3ProjectStream
|
||||
XMMATRIX Transform = XMMatrixMultiply(World, View);
|
||||
Transform = XMMatrixMultiply(Transform, Projection);
|
||||
|
||||
const uint8_t* pInputVector = (const uint8_t*)pInputStream;
|
||||
uint8_t* pOutputVector = (uint8_t*)pOutputStream;
|
||||
auto pInputVector = reinterpret_cast<const uint8_t*>(pInputStream);
|
||||
auto pOutputVector = reinterpret_cast<uint8_t*>(pOutputStream);
|
||||
|
||||
size_t i = 0;
|
||||
size_t four = VectorCount >> 2;
|
||||
@ -11669,7 +11674,7 @@ inline XMFLOAT3* XM_CALLCONV XMVector3ProjectStream
|
||||
{
|
||||
if (OutputStride == sizeof(XMFLOAT3))
|
||||
{
|
||||
if ( !((uintptr_t)pOutputStream & 0xF) )
|
||||
if ( !(reinterpret_cast<uintptr_t>(pOutputStream) & 0xF) )
|
||||
{
|
||||
// Packed input, aligned & packed output
|
||||
for (size_t j = 0; j < four; ++j)
|
||||
@ -12078,18 +12083,18 @@ inline XMFLOAT3* XM_CALLCONV XMVector3UnprojectStream
|
||||
Transform = XMMatrixMultiply(Transform, Projection);
|
||||
Transform = XMMatrixInverse(nullptr, Transform);
|
||||
|
||||
const uint8_t* pInputVector = (const uint8_t*)pInputStream;
|
||||
uint8_t* pOutputVector = (uint8_t*)pOutputStream;
|
||||
auto pInputVector = reinterpret_cast<const uint8_t*>(pInputStream);
|
||||
auto pOutputVector = reinterpret_cast<uint8_t*>(pOutputStream);
|
||||
|
||||
for (size_t i = 0; i < VectorCount; i++)
|
||||
{
|
||||
XMVECTOR V = XMLoadFloat3((const XMFLOAT3*)pInputVector);
|
||||
XMVECTOR V = XMLoadFloat3(reinterpret_cast<const XMFLOAT3*>(pInputVector));
|
||||
|
||||
XMVECTOR Result = XMVectorMultiplyAdd(V, Scale, Offset);
|
||||
|
||||
Result = XMVector3TransformCoord(Result, Transform);
|
||||
|
||||
XMStoreFloat3((XMFLOAT3*)pOutputVector, Result);
|
||||
XMStoreFloat3(reinterpret_cast<XMFLOAT3*>(pOutputVector), Result);
|
||||
|
||||
pInputVector += InputStride;
|
||||
pOutputVector += OutputStride;
|
||||
@ -12102,8 +12107,8 @@ inline XMFLOAT3* XM_CALLCONV XMVector3UnprojectStream
|
||||
Transform = XMMatrixMultiply(Transform, Projection);
|
||||
Transform = XMMatrixInverse(nullptr, Transform);
|
||||
|
||||
const uint8_t* pInputVector = (const uint8_t*)pInputStream;
|
||||
uint8_t* pOutputVector = (uint8_t*)pOutputStream;
|
||||
auto pInputVector = reinterpret_cast<const uint8_t*>(pInputStream);
|
||||
auto pOutputVector = reinterpret_cast<uint8_t*>(pOutputStream);
|
||||
|
||||
float sx = 1.f / (ViewportWidth * 0.5f);
|
||||
float sy = 1.f / (-ViewportHeight * 0.5f);
|
||||
@ -12201,11 +12206,15 @@ inline XMFLOAT3* XM_CALLCONV XMVector3UnprojectStream
|
||||
|
||||
if (i < VectorCount)
|
||||
{
|
||||
float32x2_t ScaleL = vcreate_f32(((uint64_t)*(const uint32_t *)&sx) | ((uint64_t)(*(const uint32_t *)&sy) << 32));
|
||||
float32x2_t ScaleH = vcreate_f32((uint64_t)*(const uint32_t *)&sz);
|
||||
float32x2_t ScaleL = vcreate_f32(
|
||||
static_cast<uint64_t>(*reinterpret_cast<const uint32_t *>(&sx))
|
||||
| (static_cast<uint64_t>(*reinterpret_cast<const uint32_t *>(&sy)) << 32));
|
||||
float32x2_t ScaleH = vcreate_f32(static_cast<uint64_t>(*reinterpret_cast<const uint32_t *>(&sz)));
|
||||
|
||||
float32x2_t OffsetL = vcreate_f32(((uint64_t)*(const uint32_t *)&ox) | ((uint64_t)(*(const uint32_t *)&oy) << 32));
|
||||
float32x2_t OffsetH = vcreate_f32((uint64_t)*(const uint32_t *)&oz);
|
||||
float32x2_t OffsetL = vcreate_f32(
|
||||
static_cast<uint64_t>(*reinterpret_cast<const uint32_t *>(&ox))
|
||||
| (static_cast<uint64_t>(*reinterpret_cast<const uint32_t *>(&oy)) << 32));
|
||||
float32x2_t OffsetH = vcreate_f32(static_cast<uint64_t>(*reinterpret_cast<const uint32_t *>(&oz)));
|
||||
|
||||
for (; i < VectorCount; i++)
|
||||
{
|
||||
@ -12259,8 +12268,8 @@ inline XMFLOAT3* XM_CALLCONV XMVector3UnprojectStream
|
||||
Transform = XMMatrixMultiply(Transform, Projection);
|
||||
Transform = XMMatrixInverse(nullptr, Transform);
|
||||
|
||||
const uint8_t* pInputVector = (const uint8_t*)pInputStream;
|
||||
uint8_t* pOutputVector = (uint8_t*)pOutputStream;
|
||||
auto pInputVector = reinterpret_cast<const uint8_t*>(pInputStream);
|
||||
auto pOutputVector = reinterpret_cast<uint8_t*>(pOutputStream);
|
||||
|
||||
size_t i = 0;
|
||||
size_t four = VectorCount >> 2;
|
||||
@ -12270,7 +12279,7 @@ inline XMFLOAT3* XM_CALLCONV XMVector3UnprojectStream
|
||||
{
|
||||
if (OutputStride == sizeof(XMFLOAT3))
|
||||
{
|
||||
if ( !((uintptr_t)pOutputStream & 0xF) )
|
||||
if ( !(reinterpret_cast<uintptr_t>(pOutputStream) & 0xF) )
|
||||
{
|
||||
// Packed input, aligned & packed output
|
||||
for (size_t j = 0; j < four; ++j)
|
||||
@ -14149,8 +14158,8 @@ inline XMFLOAT4* XM_CALLCONV XMVector4TransformStream
|
||||
|
||||
#if defined(_XM_NO_INTRINSICS_)
|
||||
|
||||
const uint8_t* pInputVector = (const uint8_t*)pInputStream;
|
||||
uint8_t* pOutputVector = (uint8_t*)pOutputStream;
|
||||
auto pInputVector = reinterpret_cast<const uint8_t*>(pInputStream);
|
||||
auto pOutputVector = reinterpret_cast<uint8_t*>(pOutputStream);
|
||||
|
||||
const XMVECTOR row0 = M.r[0];
|
||||
const XMVECTOR row1 = M.r[1];
|
||||
@ -14159,7 +14168,7 @@ inline XMFLOAT4* XM_CALLCONV XMVector4TransformStream
|
||||
|
||||
for (size_t i = 0; i < VectorCount; i++)
|
||||
{
|
||||
XMVECTOR V = XMLoadFloat4((const XMFLOAT4*)pInputVector);
|
||||
XMVECTOR V = XMLoadFloat4(reinterpret_cast<const XMFLOAT4*>(pInputVector));
|
||||
XMVECTOR W = XMVectorSplatW(V);
|
||||
XMVECTOR Z = XMVectorSplatZ(V);
|
||||
XMVECTOR Y = XMVectorSplatY(V);
|
||||
@ -14175,7 +14184,7 @@ inline XMFLOAT4* XM_CALLCONV XMVector4TransformStream
|
||||
#pragma prefast(disable : 26015, "PREfast noise: Esp:1307" )
|
||||
#endif
|
||||
|
||||
XMStoreFloat4((XMFLOAT4*)pOutputVector, Result);
|
||||
XMStoreFloat4(reinterpret_cast<XMFLOAT4*>(pOutputVector), Result);
|
||||
|
||||
#ifdef _PREFAST_
|
||||
#pragma prefast(pop)
|
||||
@ -14188,8 +14197,8 @@ inline XMFLOAT4* XM_CALLCONV XMVector4TransformStream
|
||||
return pOutputStream;
|
||||
|
||||
#elif defined(_XM_ARM_NEON_INTRINSICS_)
|
||||
const uint8_t* pInputVector = (const uint8_t*)pInputStream;
|
||||
uint8_t* pOutputVector = (uint8_t*)pOutputStream;
|
||||
auto pInputVector = reinterpret_cast<const uint8_t*>(pInputStream);
|
||||
auto pOutputVector = reinterpret_cast<uint8_t*>(pOutputStream);
|
||||
|
||||
const XMVECTOR row0 = M.r[0];
|
||||
const XMVECTOR row1 = M.r[1];
|
||||
@ -14286,17 +14295,17 @@ inline XMFLOAT4* XM_CALLCONV XMVector4TransformStream
|
||||
|
||||
return pOutputStream;
|
||||
#elif defined(_XM_SSE_INTRINSICS_)
|
||||
const uint8_t* pInputVector = (const uint8_t*)pInputStream;
|
||||
uint8_t* pOutputVector = (uint8_t*)pOutputStream;
|
||||
auto pInputVector = reinterpret_cast<const uint8_t*>(pInputStream);
|
||||
auto pOutputVector = reinterpret_cast<uint8_t*>(pOutputStream);
|
||||
|
||||
const XMVECTOR row0 = M.r[0];
|
||||
const XMVECTOR row1 = M.r[1];
|
||||
const XMVECTOR row2 = M.r[2];
|
||||
const XMVECTOR row3 = M.r[3];
|
||||
|
||||
if ( !((uintptr_t)pOutputStream & 0xF) && !(OutputStride & 0xF) )
|
||||
if ( !(reinterpret_cast<uintptr_t>(pOutputStream) & 0xF) && !(OutputStride & 0xF) )
|
||||
{
|
||||
if ( !((uintptr_t)pInputStream & 0xF) && !(InputStride & 0xF) )
|
||||
if ( !(reinterpret_cast<uintptr_t>(pInputStream) & 0xF) && !(InputStride & 0xF) )
|
||||
{
|
||||
// Aligned input, aligned output
|
||||
for (size_t i = 0; i < VectorCount; i++)
|
||||
@ -14351,7 +14360,7 @@ inline XMFLOAT4* XM_CALLCONV XMVector4TransformStream
|
||||
}
|
||||
else
|
||||
{
|
||||
if ( !((uintptr_t)pInputStream & 0xF) && !(InputStride & 0xF) )
|
||||
if ( !(reinterpret_cast<uintptr_t>(pInputStream) & 0xF) && !(InputStride & 0xF) )
|
||||
{
|
||||
// Aligned input, unaligned output
|
||||
for (size_t i = 0; i < VectorCount; i++)
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
Loading…
Reference in New Issue
Block a user