AuroraMiddleware/DirectXMath
1
0
Fork 0
mirror of https://github.com/microsoft/DirectXMath synced 2024-11-09 14:10:09 +00:00
Code Issues Releases Wiki Activity

Whitespace cleanup

Browse Source
This commit is contained in:
Chuck Walbourn 2019-01-30 14:13:18 -08:00
parent 4355a04696
commit ecfb475440
8 changed files with 744 additions and 744 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
Inc/DirectXCollision.h
View File

@ -73,13 +73,13 @@ struct BoundingSphere
bool Intersects( _In_ const BoundingBox& box ) const;
bool Intersects( _In_ const BoundingOrientedBox& box ) const;
bool Intersects( _In_ const BoundingFrustum& fr ) const;
bool XM_CALLCONV Intersects( _In_ FXMVECTOR V0, _In_ FXMVECTOR V1, _In_ FXMVECTOR V2 ) const;
// Triangle-sphere test
PlaneIntersectionType XM_CALLCONV Intersects( _In_ FXMVECTOR Plane ) const;
// Plane-sphere test
bool XM_CALLCONV Intersects( _In_ FXMVECTOR Origin, _In_ FXMVECTOR Direction, _Out_ float& Dist ) const;
// Ray-sphere test
@ -120,7 +120,7 @@ struct BoundingBox
XM_CONSTEXPR BoundingBox( _In_ const XMFLOAT3& center, _In_ const XMFLOAT3& extents )
: Center(center), Extents(extents) {}
// Methods
void XM_CALLCONV Transform( _Out_ BoundingBox& Out, _In_ FXMMATRIX M ) const;
void XM_CALLCONV Transform( _Out_ BoundingBox& Out, _In_ float Scale, _In_ FXMVECTOR Rotation, _In_ FXMVECTOR Translation ) const;
@ -134,7 +134,7 @@ struct BoundingBox
ContainmentType Contains( _In_ const BoundingBox& box ) const;
ContainmentType Contains( _In_ const BoundingOrientedBox& box ) const;
ContainmentType Contains( _In_ const BoundingFrustum& fr ) const;
bool Intersects( _In_ const BoundingSphere& sh ) const;
bool Intersects( _In_ const BoundingBox& box ) const;
bool Intersects( _In_ const BoundingOrientedBox& box ) const;
@ -210,7 +210,7 @@ struct BoundingOrientedBox
PlaneIntersectionType XM_CALLCONV Intersects( _In_ FXMVECTOR Plane ) const;
// Plane-OrientedBox test
bool XM_CALLCONV Intersects( _In_ FXMVECTOR Origin, _In_ FXMVECTOR Direction, _Out_ float& Dist ) const;
// Ray-OrientedBox test

184
Inc/DirectXCollision.inl
View File

@ -122,7 +122,7 @@ inline XMVECTOR PointOnLineSegmentNearestPoint( _In_ FXMVECTOR S1, _In_ FXMVECTO
}
//-----------------------------------------------------------------------------
// Test if the point (P) on the plane of the triangle is inside the triangle
// Test if the point (P) on the plane of the triangle is inside the triangle
// (V0, V1, V2).
//-----------------------------------------------------------------------------
inline XMVECTOR XM_CALLCONV PointOnPlaneInsideTriangle( _In_ FXMVECTOR P, _In_ FXMVECTOR V0, _In_ FXMVECTOR V1, _In_ GXMVECTOR V2 )
@ -130,7 +130,7 @@ inline XMVECTOR XM_CALLCONV PointOnPlaneInsideTriangle( _In_ FXMVECTOR P, _In_ F
// Compute the triangle normal.
XMVECTOR N = XMVector3Cross( XMVectorSubtract( V2, V0 ), XMVectorSubtract( V1, V0 ) );
// Compute the cross products of the vector from the base of each edge to
// Compute the cross products of the vector from the base of each edge to
// the point with each edge vector.
XMVECTOR C0 = XMVector3Cross( XMVectorSubtract( P, V0 ), XMVectorSubtract( V1, V0 ) );
XMVECTOR C1 = XMVector3Cross( XMVectorSubtract( P, V1 ), XMVectorSubtract( V2, V1 ) );
@ -421,7 +421,7 @@ inline void FastIntersectAxisAlignedBoxPlane( _In_ FXMVECTOR Center, _In_ FXMVEC
// Project the axes of the box onto the normal of the plane. Half the
// length of the projection (sometime called the "radius") is equal to
// h(u) * abs(n dot b(u))) + h(v) * abs(n dot b(v)) + h(w) * abs(n dot b(w))
// where h(i) are extents of the box, n is the plane normal, and b(i) are the
// where h(i) are extents of the box, n is the plane normal, and b(i) are the
// axes of the box. In this case b(i) = [(1,0,0), (0,1,0), (0,0,1)].
XMVECTOR Radius = XMVector3Dot( Extents, XMVectorAbs( Plane ) );
@ -442,7 +442,7 @@ inline void XM_CALLCONV FastIntersectOrientedBoxPlane( _In_ FXMVECTOR Center, _I
// Project the axes of the box onto the normal of the plane. Half the
// length of the projection (sometime called the "radius") is equal to
// h(u) * abs(n dot b(u))) + h(v) * abs(n dot b(v)) + h(w) * abs(n dot b(w))
// where h(i) are extents of the box, n is the plane normal, and b(i) are the
// where h(i) are extents of the box, n is the plane normal, and b(i) are the
// axes of the box.
XMVECTOR Radius = XMVector3Dot( Plane, Axis0 );
Radius = XMVectorInsert<0, 0, 1, 0, 0>( Radius, XMVector3Dot( Plane, Axis1 ) );
@ -523,7 +523,7 @@ inline void XM_CALLCONV BoundingSphere::Transform( BoundingSphere& Out, FXMMATRI
// Transform the center of the sphere.
XMVECTOR C = XMVector3Transform( vCenter, M );
XMVECTOR dX = XMVector3Dot( M.r[0], M.r[0] );
XMVECTOR dY = XMVector3Dot( M.r[1], M.r[1] );
XMVECTOR dZ = XMVector3Dot( M.r[2], M.r[2] );
@ -745,7 +745,7 @@ inline bool BoundingSphere::Intersects( const BoundingSphere& sh ) const
XMVECTOR vCenterB = XMLoadFloat3( &sh.Center );
XMVECTOR vRadiusB = XMVectorReplicatePtr( &sh.Radius );
// Distance squared between centers.
// Distance squared between centers.
XMVECTOR Delta = XMVectorSubtract( vCenterB, vCenterA );
XMVECTOR DistanceSquared = XMVector3LengthSq( Delta );
@ -789,7 +789,7 @@ inline bool BoundingSphere::Intersects( const BoundingFrustum& fr ) const
_Use_decl_annotations_
inline bool XM_CALLCONV BoundingSphere::Intersects( FXMVECTOR V0, FXMVECTOR V1, FXMVECTOR V2 ) const
{
// Load the sphere.
// Load the sphere.
XMVECTOR vCenter = XMLoadFloat3( &Center );
XMVECTOR vRadius = XMVectorReplicatePtr( &Radius );
@ -810,7 +810,7 @@ inline bool XM_CALLCONV BoundingSphere::Intersects( FXMVECTOR V0, FXMVECTOR V1,
// Project the center of the sphere onto the plane of the triangle.
XMVECTOR Point = XMVectorNegativeMultiplySubtract( N, Dist, vCenter );
// Is it inside all the edges? If so we intersect because the distance
// Is it inside all the edges? If so we intersect because the distance
// to the plane is less than the radius.
XMVECTOR Intersection = DirectX::Internal::PointOnPlaneInsideTriangle( Point, V0, V1, V2 );
@ -820,21 +820,21 @@ inline bool XM_CALLCONV BoundingSphere::Intersects( FXMVECTOR V0, FXMVECTOR V1,
// Edge 0,1
Point = DirectX::Internal::PointOnLineSegmentNearestPoint( V0, V1, vCenter );
// If the distance to the center of the sphere to the point is less than
// If the distance to the center of the sphere to the point is less than
// the radius of the sphere then it must intersect.
Intersection = XMVectorOrInt( Intersection, XMVectorLessOrEqual( XMVector3LengthSq( XMVectorSubtract( vCenter, Point ) ), RadiusSq ) );
// Edge 1,2
Point = DirectX::Internal::PointOnLineSegmentNearestPoint( V1, V2, vCenter );
// If the distance to the center of the sphere to the point is less than
// If the distance to the center of the sphere to the point is less than
// the radius of the sphere then it must intersect.
Intersection = XMVectorOrInt( Intersection, XMVectorLessOrEqual( XMVector3LengthSq( XMVectorSubtract( vCenter, Point ) ), RadiusSq ) );
// Edge 2,0
Point = DirectX::Internal::PointOnLineSegmentNearestPoint( V2, V0, vCenter );
// If the distance to the center of the sphere to the point is less than
// If the distance to the center of the sphere to the point is less than
// the radius of the sphere then it must intersect.
Intersection = XMVectorOrInt( Intersection, XMVectorLessOrEqual( XMVector3LengthSq( XMVectorSubtract( vCenter, Point ) ), RadiusSq ) );
@ -899,7 +899,7 @@ inline bool XM_CALLCONV BoundingSphere::Intersects( FXMVECTOR Origin, FXMVECTOR
XMVECTOR NoIntersection;
// If the ray origin is outside the sphere and the center of the sphere is
// If the ray origin is outside the sphere and the center of the sphere is
// behind the ray origin there is no intersection.
NoIntersection = XMVectorAndInt( XMVectorLess( s, XMVectorZero() ), XMVectorGreater( l2, r2 ) );
@ -1019,7 +1019,7 @@ inline void BoundingSphere::CreateMerged( BoundingSphere& Out, const BoundingSph
float t1 = XMMin( -r1, d-r2 );
float t2 = XMMax( r1, d+r2 );
float t_5 = (t2 - t1) * 0.5f;
XMVECTOR NCenter = XMVectorAdd( Center1, XMVectorMultiply( N, XMVectorReplicate( t_5 + t1 ) ) );
XMStoreFloat3( &Out.Center, NCenter );
@ -1049,10 +1049,10 @@ inline void BoundingSphere::CreateFromBoundingBox( BoundingSphere& Out, const Bo
//-----------------------------------------------------------------------------
// Find the approximate smallest enclosing bounding sphere for a set of
// points. Exact computation of the smallest enclosing bounding sphere is
// Find the approximate smallest enclosing bounding sphere for a set of
// points. Exact computation of the smallest enclosing bounding sphere is
// possible but is slower and requires a more complex algorithm.
// The algorithm is based on Jack Ritter, "An Efficient Bounding Sphere",
// The algorithm is based on Jack Ritter, "An Efficient Bounding Sphere",
// Graphics Gems.
//-----------------------------------------------------------------------------
_Use_decl_annotations_
@ -1538,7 +1538,7 @@ inline bool XM_CALLCONV BoundingBox::Intersects( FXMVECTOR V0, FXMVECTOR V1, FXM
XMVECTOR BoxMin = XMVectorSubtract( vCenter, vExtents );
XMVECTOR BoxMax = XMVectorAdd( vCenter, vExtents );
// Test the axes of the box (in effect test the AAB against the minimal AAB
// Test the axes of the box (in effect test the AAB against the minimal AAB
// around the triangle).
XMVECTOR TriMin = XMVectorMin( XMVectorMin( V0, V1 ), V2 );
XMVECTOR TriMax = XMVectorMax( XMVectorMax( V0, V1 ), V2 );
@ -1721,7 +1721,7 @@ inline PlaneIntersectionType XM_CALLCONV BoundingBox::Intersects( FXMVECTOR Plan
//-----------------------------------------------------------------------------
// Compute the intersection of a ray (Origin, Direction) with an axis aligned
// Compute the intersection of a ray (Origin, Direction) with an axis aligned
// box using the slabs method.
//-----------------------------------------------------------------------------
_Use_decl_annotations_
@ -2260,7 +2260,7 @@ inline bool BoundingOrientedBox::Intersects( const BoundingBox& box ) const
//-----------------------------------------------------------------------------
// Fast oriented box / oriented box intersection test using the separating axis
// Fast oriented box / oriented box intersection test using the separating axis
// theorem.
//-----------------------------------------------------------------------------
_Use_decl_annotations_
@ -2287,7 +2287,7 @@ inline bool BoundingOrientedBox::Intersects( const BoundingOrientedBox& box ) co
//
// a(u) = axes of A = (1,0,0), (0,1,0), (0,0,1)
// b(u) = axes of B relative to A = (r00,r10,r20), (r01,r11,r21), (r02,r12,r22)
//
//
// For each possible separating axis l:
// d(A) = sum (for i = u,v,w) h(A)(i) * abs( a(i) dot l )
// d(B) = sum (for i = u,v,w) h(B)(i) * abs( b(i) dot l )
@ -2339,7 +2339,7 @@ inline bool BoundingOrientedBox::Intersects( const BoundingOrientedBox& box ) co
d = XMVectorSplatY( t );
d_A = XMVectorSplatY( h_A );
d_B = XMVector3Dot( h_B, AR1X );
NoIntersection = XMVectorOrInt( NoIntersection,
NoIntersection = XMVectorOrInt( NoIntersection,
XMVectorGreater( XMVectorAbs(d), XMVectorAdd( d_A, d_B ) ) );
// l = a(w) = (0, 0, 1)
@ -2349,7 +2349,7 @@ inline bool BoundingOrientedBox::Intersects( const BoundingOrientedBox& box ) co
d = XMVectorSplatZ( t );
d_A = XMVectorSplatZ( h_A );
d_B = XMVector3Dot( h_B, AR2X );
NoIntersection = XMVectorOrInt( NoIntersection,
NoIntersection = XMVectorOrInt( NoIntersection,
XMVectorGreater( XMVectorAbs(d), XMVectorAdd( d_A, d_B ) ) );
// l = b(u) = (r00, r10, r20)
@ -2358,7 +2358,7 @@ inline bool BoundingOrientedBox::Intersects( const BoundingOrientedBox& box ) co
d = XMVector3Dot( t, RX0 );
d_A = XMVector3Dot( h_A, ARX0 );
d_B = XMVectorSplatX( h_B );
NoIntersection = XMVectorOrInt( NoIntersection,
NoIntersection = XMVectorOrInt( NoIntersection,
XMVectorGreater( XMVectorAbs(d), XMVectorAdd( d_A, d_B ) ) );
// l = b(v) = (r01, r11, r21)
@ -2367,7 +2367,7 @@ inline bool BoundingOrientedBox::Intersects( const BoundingOrientedBox& box ) co
d = XMVector3Dot( t, RX1 );
d_A = XMVector3Dot( h_A, ARX1 );
d_B = XMVectorSplatY( h_B );
NoIntersection = XMVectorOrInt( NoIntersection,
NoIntersection = XMVectorOrInt( NoIntersection,
XMVectorGreater( XMVectorAbs(d), XMVectorAdd( d_A, d_B ) ) );
// l = b(w) = (r02, r12, r22)
@ -2376,7 +2376,7 @@ inline bool BoundingOrientedBox::Intersects( const BoundingOrientedBox& box ) co
d = XMVector3Dot( t, RX2 );
d_A = XMVector3Dot( h_A, ARX2 );
d_B = XMVectorSplatZ( h_B );
NoIntersection = XMVectorOrInt( NoIntersection,
NoIntersection = XMVectorOrInt( NoIntersection,
XMVectorGreater( XMVectorAbs(d), XMVectorAdd( d_A, d_B ) ) );
// l = a(u) x b(u) = (0, -r20, r10)
@ -2385,7 +2385,7 @@ inline bool BoundingOrientedBox::Intersects( const BoundingOrientedBox& box ) co
d = XMVector3Dot( t, XMVectorPermute<XM_PERMUTE_0W, XM_PERMUTE_1Z, XM_PERMUTE_0Y, XM_PERMUTE_0X>( RX0, XMVectorNegate( RX0 ) ) );
d_A = XMVector3Dot( h_A, XMVectorSwizzle<XM_SWIZZLE_W, XM_SWIZZLE_Z, XM_SWIZZLE_Y, XM_SWIZZLE_X>( ARX0 ) );
d_B = XMVector3Dot( h_B, XMVectorSwizzle<XM_SWIZZLE_W, XM_SWIZZLE_Z, XM_SWIZZLE_Y, XM_SWIZZLE_X>( AR0X ) );
NoIntersection = XMVectorOrInt( NoIntersection,
NoIntersection = XMVectorOrInt( NoIntersection,
XMVectorGreater( XMVectorAbs(d), XMVectorAdd( d_A, d_B ) ) );
// l = a(u) x b(v) = (0, -r21, r11)
@ -2394,7 +2394,7 @@ inline bool BoundingOrientedBox::Intersects( const BoundingOrientedBox& box ) co
d = XMVector3Dot( t, XMVectorPermute<XM_PERMUTE_0W, XM_PERMUTE_1Z, XM_PERMUTE_0Y, XM_PERMUTE_0X>( RX1, XMVectorNegate( RX1 ) ) );
d_A = XMVector3Dot( h_A, XMVectorSwizzle<XM_SWIZZLE_W, XM_SWIZZLE_Z, XM_SWIZZLE_Y, XM_SWIZZLE_X>( ARX1 ) );
d_B = XMVector3Dot( h_B, XMVectorSwizzle<XM_SWIZZLE_Z, XM_SWIZZLE_W, XM_SWIZZLE_X, XM_SWIZZLE_Y>( AR0X ) );
NoIntersection = XMVectorOrInt( NoIntersection,
NoIntersection = XMVectorOrInt( NoIntersection,
XMVectorGreater( XMVectorAbs(d), XMVectorAdd( d_A, d_B ) ) );
// l = a(u) x b(w) = (0, -r22, r12)
@ -2403,7 +2403,7 @@ inline bool BoundingOrientedBox::Intersects( const BoundingOrientedBox& box ) co
d = XMVector3Dot( t, XMVectorPermute<XM_PERMUTE_0W, XM_PERMUTE_1Z, XM_PERMUTE_0Y, XM_PERMUTE_0X>( RX2, XMVectorNegate( RX2 ) ) );
d_A = XMVector3Dot( h_A, XMVectorSwizzle<XM_SWIZZLE_W, XM_SWIZZLE_Z, XM_SWIZZLE_Y, XM_SWIZZLE_X>( ARX2 ) );
d_B = XMVector3Dot( h_B, XMVectorSwizzle<XM_SWIZZLE_Y, XM_SWIZZLE_X, XM_SWIZZLE_W, XM_SWIZZLE_Z>( AR0X ) );
NoIntersection = XMVectorOrInt( NoIntersection,
NoIntersection = XMVectorOrInt( NoIntersection,
XMVectorGreater( XMVectorAbs(d), XMVectorAdd( d_A, d_B ) ) );
// l = a(v) x b(u) = (r20, 0, -r00)
@ -2412,7 +2412,7 @@ inline bool BoundingOrientedBox::Intersects( const BoundingOrientedBox& box ) co
d = XMVector3Dot( t, XMVectorPermute<XM_PERMUTE_0Z, XM_PERMUTE_0W, XM_PERMUTE_1X, XM_PERMUTE_0Y>( RX0, XMVectorNegate( RX0 ) ) );
d_A = XMVector3Dot( h_A, XMVectorSwizzle<XM_SWIZZLE_Z, XM_SWIZZLE_W, XM_SWIZZLE_X, XM_SWIZZLE_Y>( ARX0 ) );
d_B = XMVector3Dot( h_B, XMVectorSwizzle<XM_SWIZZLE_W, XM_SWIZZLE_Z, XM_SWIZZLE_Y, XM_SWIZZLE_X>( AR1X ) );
NoIntersection = XMVectorOrInt( NoIntersection,
NoIntersection = XMVectorOrInt( NoIntersection,
XMVectorGreater( XMVectorAbs(d), XMVectorAdd( d_A, d_B ) ) );
// l = a(v) x b(v) = (r21, 0, -r01)
@ -2421,7 +2421,7 @@ inline bool BoundingOrientedBox::Intersects( const BoundingOrientedBox& box ) co
d = XMVector3Dot( t, XMVectorPermute<XM_PERMUTE_0Z, XM_PERMUTE_0W, XM_PERMUTE_1X, XM_PERMUTE_0Y>( RX1, XMVectorNegate( RX1 ) ) );
d_A = XMVector3Dot( h_A, XMVectorSwizzle<XM_SWIZZLE_Z, XM_SWIZZLE_W, XM_SWIZZLE_X, XM_SWIZZLE_Y>( ARX1 ) );
d_B = XMVector3Dot( h_B, XMVectorSwizzle<XM_SWIZZLE_Z, XM_SWIZZLE_W, XM_SWIZZLE_X, XM_SWIZZLE_Y>( AR1X ) );
NoIntersection = XMVectorOrInt( NoIntersection,
NoIntersection = XMVectorOrInt( NoIntersection,
XMVectorGreater( XMVectorAbs(d), XMVectorAdd( d_A, d_B ) ) );
// l = a(v) x b(w) = (r22, 0, -r02)
@ -2430,7 +2430,7 @@ inline bool BoundingOrientedBox::Intersects( const BoundingOrientedBox& box ) co
d = XMVector3Dot( t, XMVectorPermute<XM_PERMUTE_0Z, XM_PERMUTE_0W, XM_PERMUTE_1X, XM_PERMUTE_0Y>( RX2, XMVectorNegate( RX2 ) ) );
d_A = XMVector3Dot( h_A, XMVectorSwizzle<XM_SWIZZLE_Z, XM_SWIZZLE_W, XM_SWIZZLE_X, XM_SWIZZLE_Y>( ARX2 ) );
d_B = XMVector3Dot( h_B, XMVectorSwizzle<XM_SWIZZLE_Y, XM_SWIZZLE_X, XM_SWIZZLE_W, XM_SWIZZLE_Z>( AR1X ) );
NoIntersection = XMVectorOrInt( NoIntersection,
NoIntersection = XMVectorOrInt( NoIntersection,
XMVectorGreater( XMVectorAbs(d), XMVectorAdd( d_A, d_B ) ) );
// l = a(w) x b(u) = (-r10, r00, 0)
@ -2439,7 +2439,7 @@ inline bool BoundingOrientedBox::Intersects( const BoundingOrientedBox& box ) co
d = XMVector3Dot( t, XMVectorPermute<XM_PERMUTE_1Y, XM_PERMUTE_0X, XM_PERMUTE_0W, XM_PERMUTE_0Z>( RX0, XMVectorNegate( RX0 ) ) );
d_A = XMVector3Dot( h_A, XMVectorSwizzle<XM_SWIZZLE_Y, XM_SWIZZLE_X, XM_SWIZZLE_W, XM_SWIZZLE_Z>( ARX0 ) );
d_B = XMVector3Dot( h_B, XMVectorSwizzle<XM_SWIZZLE_W, XM_SWIZZLE_Z, XM_SWIZZLE_Y, XM_SWIZZLE_X>( AR2X ) );
NoIntersection = XMVectorOrInt( NoIntersection,
NoIntersection = XMVectorOrInt( NoIntersection,
XMVectorGreater( XMVectorAbs(d), XMVectorAdd( d_A, d_B ) ) );
// l = a(w) x b(v) = (-r11, r01, 0)
@ -2448,7 +2448,7 @@ inline bool BoundingOrientedBox::Intersects( const BoundingOrientedBox& box ) co
d = XMVector3Dot( t, XMVectorPermute<XM_PERMUTE_1Y, XM_PERMUTE_0X, XM_PERMUTE_0W, XM_PERMUTE_0Z>( RX1, XMVectorNegate( RX1 ) ) );
d_A = XMVector3Dot( h_A, XMVectorSwizzle<XM_SWIZZLE_Y, XM_SWIZZLE_X, XM_SWIZZLE_W, XM_SWIZZLE_Z>( ARX1 ) );
d_B = XMVector3Dot( h_B, XMVectorSwizzle<XM_SWIZZLE_Z, XM_SWIZZLE_W, XM_SWIZZLE_X, XM_SWIZZLE_Y>( AR2X ) );
NoIntersection = XMVectorOrInt( NoIntersection,
NoIntersection = XMVectorOrInt( NoIntersection,
XMVectorGreater( XMVectorAbs(d), XMVectorAdd( d_A, d_B ) ) );
// l = a(w) x b(w) = (-r12, r02, 0)
@ -2457,7 +2457,7 @@ inline bool BoundingOrientedBox::Intersects( const BoundingOrientedBox& box ) co
d = XMVector3Dot( t, XMVectorPermute<XM_PERMUTE_1Y, XM_PERMUTE_0X, XM_PERMUTE_0W, XM_PERMUTE_0Z>( RX2, XMVectorNegate( RX2 ) ) );
d_A = XMVector3Dot( h_A, XMVectorSwizzle<XM_SWIZZLE_Y, XM_SWIZZLE_X, XM_SWIZZLE_W, XM_SWIZZLE_Z>( ARX2 ) );
d_B = XMVector3Dot( h_B, XMVectorSwizzle<XM_SWIZZLE_Y, XM_SWIZZLE_X, XM_SWIZZLE_W, XM_SWIZZLE_Z>( AR2X ) );
NoIntersection = XMVectorOrInt( NoIntersection,
NoIntersection = XMVectorOrInt( NoIntersection,
XMVectorGreater( XMVectorAbs(d), XMVectorAdd( d_A, d_B ) ) );
// No seperating axis found, boxes must intersect.
@ -2684,13 +2684,13 @@ inline void BoundingOrientedBox::CreateFromBoundingBox( BoundingOrientedBox& Out
//-----------------------------------------------------------------------------
// Find the approximate minimum oriented bounding box containing a set of
// points. Exact computation of minimum oriented bounding box is possible but
// Find the approximate minimum oriented bounding box containing a set of
// points. Exact computation of minimum oriented bounding box is possible but
// is slower and requires a more complex algorithm.
// The algorithm works by computing the inertia tensor of the points and then
// using the eigenvectors of the intertia tensor as the axes of the box.
// Computing the intertia tensor of the convex hull of the points will usually
// result in better bounding box but the computation is more complex.
// Computing the intertia tensor of the convex hull of the points will usually
// result in better bounding box but the computation is more complex.
// Exact computation of the minimum oriented bounding box is possible but the
// best know algorithm is O(N^3) and is significanly more complex to implement.
//-----------------------------------------------------------------------------
@ -2747,9 +2747,9 @@ inline void BoundingOrientedBox::CreateFromPoints( BoundingOrientedBox& Out, siz
R.r[2] = XMVectorSetW( v3, 0.f );
R.r[3] = g_XMIdentityR3.v;
// Multiply by -1 to convert the matrix into a right handed coordinate
// system (Det ~= 1) in case the eigenvectors form a left handed
// coordinate system (Det ~= -1) because XMQuaternionRotationMatrix only
// Multiply by -1 to convert the matrix into a right handed coordinate
// system (Det ~= 1) in case the eigenvectors form a left handed
// coordinate system (Det ~= -1) because XMQuaternionRotationMatrix only
// works on right handed matrices.
XMVECTOR Det = XMMatrixDeterminant( R );
@ -3003,7 +3003,7 @@ inline ContainmentType XM_CALLCONV BoundingFrustum::Contains( FXMVECTOR V0, FXMV
XMVECTOR LeftPlane = XMVectorSet( -1.0f, 0.0f, LeftSlope, 0.0f );
LeftPlane = DirectX::Internal::XMPlaneTransform( LeftPlane, vOrientation, vOrigin );
LeftPlane = XMPlaneNormalize( LeftPlane );
XMVECTOR TopPlane = XMVectorSet( 0.0f, 1.0f, -TopSlope, 0.0f );
TopPlane = DirectX::Internal::XMPlaneTransform( TopPlane, vOrientation, vOrigin );
TopPlane = XMPlaneNormalize( TopPlane );
@ -3040,7 +3040,7 @@ inline ContainmentType BoundingFrustum::Contains( const BoundingSphere& sh ) con
XMVECTOR LeftPlane = XMVectorSet( -1.0f, 0.0f, LeftSlope, 0.0f );
LeftPlane = DirectX::Internal::XMPlaneTransform( LeftPlane, vOrientation, vOrigin );
LeftPlane = XMPlaneNormalize( LeftPlane );
XMVECTOR TopPlane = XMVectorSet( 0.0f, 1.0f, -TopSlope, 0.0f );
TopPlane = DirectX::Internal::XMPlaneTransform( TopPlane, vOrientation, vOrigin );
TopPlane = XMPlaneNormalize( TopPlane );
@ -3077,7 +3077,7 @@ inline ContainmentType BoundingFrustum::Contains( const BoundingBox& box ) const
XMVECTOR LeftPlane = XMVectorSet( -1.0f, 0.0f, LeftSlope, 0.0f );
LeftPlane = DirectX::Internal::XMPlaneTransform( LeftPlane, vOrientation, vOrigin );
LeftPlane = XMPlaneNormalize( LeftPlane );
XMVECTOR TopPlane = XMVectorSet( 0.0f, 1.0f, -TopSlope, 0.0f );
TopPlane = DirectX::Internal::XMPlaneTransform( TopPlane, vOrientation, vOrigin );
TopPlane = XMPlaneNormalize( TopPlane );
@ -3114,7 +3114,7 @@ inline ContainmentType BoundingFrustum::Contains( const BoundingOrientedBox& box
XMVECTOR LeftPlane = XMVectorSet( -1.0f, 0.0f, LeftSlope, 0.0f );
LeftPlane = DirectX::Internal::XMPlaneTransform( LeftPlane, vOrientation, vOrigin );
LeftPlane = XMPlaneNormalize( LeftPlane );
XMVECTOR TopPlane = XMVectorSet( 0.0f, 1.0f, -TopSlope, 0.0f );
TopPlane = DirectX::Internal::XMPlaneTransform( TopPlane, vOrientation, vOrigin );
TopPlane = XMPlaneNormalize( TopPlane );
@ -3151,7 +3151,7 @@ inline ContainmentType BoundingFrustum::Contains( const BoundingFrustum& fr ) co
XMVECTOR LeftPlane = XMVectorSet( -1.0f, 0.0f, LeftSlope, 0.0f );
LeftPlane = DirectX::Internal::XMPlaneTransform( LeftPlane, vOrientation, vOrigin );
LeftPlane = XMPlaneNormalize( LeftPlane );
XMVECTOR TopPlane = XMVectorSet( 0.0f, 1.0f, -TopSlope, 0.0f );
TopPlane = DirectX::Internal::XMPlaneTransform( TopPlane, vOrientation, vOrigin );
TopPlane = XMPlaneNormalize( TopPlane );
@ -3168,7 +3168,7 @@ inline ContainmentType BoundingFrustum::Contains( const BoundingFrustum& fr ) co
// Exact sphere vs frustum test. The algorithm first checks the sphere against
// the planes of the frustum, then if the plane checks were indeterminate finds
// the nearest feature (plane, line, point) on the frustum to the center of the
// sphere and compares the distance to the nearest feature to the radius of the
// sphere and compares the distance to the nearest feature to the radius of the
// sphere
//-----------------------------------------------------------------------------
_Use_decl_annotations_
@ -3228,7 +3228,7 @@ inline bool BoundingFrustum::Intersects( const BoundingSphere& sh ) const
CenterInsideAll = XMVectorAndInt( CenterInsideAll, XMVectorLessOrEqual( Dist[i], Zero ) );
}
// If the sphere is outside any of the planes it is outside.
// If the sphere is outside any of the planes it is outside.
if ( XMVector4EqualInt( Outside, XMVectorTrueInt() ) )
return false;
@ -3236,13 +3236,13 @@ inline bool BoundingFrustum::Intersects( const BoundingSphere& sh ) const
if ( XMVector4EqualInt( InsideAll, XMVectorTrueInt() ) )
return true;
// If the center of the sphere is inside all planes and the sphere intersects
// If the center of the sphere is inside all planes and the sphere intersects
// one or more planes then it must intersect.
if ( XMVector4EqualInt( CenterInsideAll, XMVectorTrueInt() ) )
return true;
// The sphere may be outside the frustum or intersecting the frustum.
// Find the nearest feature (face, edge, or corner) on the frustum
// Find the nearest feature (face, edge, or corner) on the frustum
// to the sphere.
// The faces adjacent to each face are:
@ -3266,11 +3266,11 @@ inline bool BoundingFrustum::Intersects( const BoundingSphere& sh ) const
// Set w of the point to one.
Point = XMVectorInsert<0, 0, 0, 0, 1>( Point, XMVectorSplatOne() );
// If the point is inside the face (inside the adjacent planes) then
// this plane is the nearest feature.
XMVECTOR InsideFace = XMVectorTrueInt();
for ( size_t j = 0; j < 4; j++ )
{
size_t plane_index = adjacent_faces[i][j];
@ -3278,10 +3278,10 @@ inline bool BoundingFrustum::Intersects( const BoundingSphere& sh ) const
InsideFace = XMVectorAndInt( InsideFace,
XMVectorLessOrEqual( XMVector4Dot( Point, Planes[plane_index] ), Zero ) );
}
// Since we have already checked distance from the plane we know that the
// sphere must intersect if this plane is the nearest feature.
Intersects = XMVectorOrInt( Intersects,
Intersects = XMVectorOrInt( Intersects,
XMVectorAndInt( XMVectorGreater( Dist[i], Zero ), InsideFace ) );
}
@ -3330,7 +3330,7 @@ inline bool BoundingFrustum::Intersects( const BoundingSphere& sh ) const
XMVECTOR DistSq = XMVector3Dot( Delta, Delta );
// If the distance to the center of the sphere to the point is less than
// If the distance to the center of the sphere to the point is less than
// the radius of the sphere then it must intersect.
Intersects = XMVectorOrInt( Intersects, XMVectorLessOrEqual( DistSq, RadiusSq ) );
}
@ -3389,7 +3389,7 @@ inline bool BoundingFrustum::Intersects( const BoundingOrientedBox& box ) const
assert( DirectX::Internal::XMQuaternionIsUnit( BoxOrientation ) );
// Transform the oriented box into the space of the frustum in order to
// Transform the oriented box into the space of the frustum in order to
// minimize the number of transforms we have to do.
Center = XMVector3InverseRotate( XMVectorSubtract( Center, vOrigin ), FrustumOrientation );
BoxOrientation = XMQuaternionMultiply( BoxOrientation, XMQuaternionConjugate( FrustumOrientation ) );
@ -3413,7 +3413,7 @@ inline bool BoundingFrustum::Intersects( const BoundingOrientedBox& box ) const
// Project the axes of the box onto the normal of the plane. Half the
// length of the projection (sometime called the "radius") is equal to
// h(u) * abs(n dot b(u))) + h(v) * abs(n dot b(v)) + h(w) * abs(n dot b(w))
// where h(i) are extents of the box, n is the plane normal, and b(i) are the
// where h(i) are extents of the box, n is the plane normal, and b(i) are the
// axes of the box.
XMVECTOR Radius = XMVector3Dot( Planes[i], R.r[0] );
Radius = XMVectorSelect( Radius, XMVector3Dot( Planes[i], R.r[1] ), SelectY );
@ -3430,7 +3430,7 @@ inline bool BoundingFrustum::Intersects( const BoundingOrientedBox& box ) const
CenterInsideAll = XMVectorAndInt( CenterInsideAll, XMVectorLessOrEqual( Dist, Zero ) );
}
// If the box is outside any of the planes it is outside.
// If the box is outside any of the planes it is outside.
if ( XMVector4EqualInt( Outside, XMVectorTrueInt() ) )
return false;
@ -3438,7 +3438,7 @@ inline bool BoundingFrustum::Intersects( const BoundingOrientedBox& box ) const
if ( XMVector4EqualInt( InsideAll, XMVectorTrueInt() ) )
return true;
// If the center of the box is inside all planes and the box intersects
// If the center of the box is inside all planes and the box intersects
// one or more planes then it must intersect.
if ( XMVector4EqualInt( CenterInsideAll, XMVectorTrueInt() ) )
return true;
@ -3582,7 +3582,7 @@ inline bool BoundingFrustum::Intersects( const BoundingFrustum& fr ) const
assert( DirectX::Internal::XMQuaternionIsUnit( OrientationA ) );
// Transform frustum A into the space of the frustum B in order to
// Transform frustum A into the space of the frustum B in order to
// minimize the number of transforms we have to do.
OriginA = XMVector3InverseRotate( XMVectorSubtract( OriginA, OriginB ), OrientationB );
OrientationA = XMQuaternionMultiply( OrientationA, XMQuaternionConjugate( OrientationB ) );
@ -3635,7 +3635,7 @@ inline bool BoundingFrustum::Intersects( const BoundingFrustum& fr ) const
InsideAll = XMVectorAndInt( InsideAll, XMVectorLessOrEqual( Max, PlaneDistB[i] ) );
}
// If the frustum A is outside any of the planes of frustum B it is outside.
// If the frustum A is outside any of the planes of frustum B it is outside.
if ( XMVector4EqualInt( Outside, XMVectorTrueInt() ) )
return false;
@ -3704,7 +3704,7 @@ inline bool BoundingFrustum::Intersects( const BoundingFrustum& fr ) const
Outside = XMVectorOrInt( Outside, XMVectorGreater( Min, PlaneDistA[i] ) );
}
// If the frustum B is outside any of the planes of frustum A it is outside.
// If the frustum B is outside any of the planes of frustum A it is outside.
if ( XMVector4EqualInt( Outside, XMVectorTrueInt() ) )
return false;
@ -3815,7 +3815,7 @@ inline bool XM_CALLCONV BoundingFrustum::Intersects( FXMVECTOR V0, FXMVECTOR V1,
InsideAll = XMVectorAndInt( InsideAll, XMVectorLessOrEqual( MaxDist, PlaneDist ) );
}
// If the triangle is outside any of the planes it is outside.
// If the triangle is outside any of the planes it is outside.
if ( XMVector4EqualInt( Outside, XMVectorTrueInt() ) )
return false;
@ -3854,7 +3854,7 @@ inline bool XM_CALLCONV BoundingFrustum::Intersects( FXMVECTOR V0, FXMVECTOR V1,
MaxDist = XMVectorMax( MaxDist, Temp );
}
Outside = XMVectorOrInt( XMVectorGreater( MinDist, Dist ), XMVectorLess( MaxDist, Dist ) );
Outside = XMVectorOrInt( XMVectorGreater( MinDist, Dist ), XMVectorLess( MaxDist, Dist ) );
if ( XMVector4EqualInt( Outside, XMVectorTrueInt() ) )
return false;
@ -3955,8 +3955,8 @@ inline PlaneIntersectionType XM_CALLCONV BoundingFrustum::Intersects( FXMVECTOR
XMVECTOR Corners7 = XMVectorMultiplyAdd( LeftBottom, vFar, vOrigin );
XMVECTOR Outside, Inside;
DirectX::Internal::FastIntersectFrustumPlane( Corners0, Corners1, Corners2, Corners3,
Corners4, Corners5, Corners6, Corners7,
DirectX::Internal::FastIntersectFrustumPlane( Corners0, Corners1, Corners2, Corners3,
Corners4, Corners5, Corners6, Corners7,
Plane, Outside, Inside );
// If the frustum is outside any plane it is outside.
@ -4065,7 +4065,7 @@ inline bool XM_CALLCONV BoundingFrustum::Intersects( FXMVECTOR rayOrigin, FXMVEC
{
Dist = distance;
return true;
}
}
Dist = 0.f;
return false;
@ -4113,43 +4113,43 @@ inline ContainmentType XM_CALLCONV BoundingFrustum::ContainedBy( FXMVECTOR Plane
XMVECTOR Outside, Inside;
// Test against each plane.
DirectX::Internal::FastIntersectFrustumPlane( Corners0, Corners1, Corners2, Corners3,
Corners4, Corners5, Corners6, Corners7,
DirectX::Internal::FastIntersectFrustumPlane( Corners0, Corners1, Corners2, Corners3,
Corners4, Corners5, Corners6, Corners7,
Plane0, Outside, Inside );
XMVECTOR AnyOutside = Outside;
XMVECTOR AllInside = Inside;
DirectX::Internal::FastIntersectFrustumPlane( Corners0, Corners1, Corners2, Corners3,
Corners4, Corners5, Corners6, Corners7,
DirectX::Internal::FastIntersectFrustumPlane( Corners0, Corners1, Corners2, Corners3,
Corners4, Corners5, Corners6, Corners7,
Plane1, Outside, Inside );
AnyOutside = XMVectorOrInt( AnyOutside, Outside );
AllInside = XMVectorAndInt( AllInside, Inside );
DirectX::Internal::FastIntersectFrustumPlane( Corners0, Corners1, Corners2, Corners3,
Corners4, Corners5, Corners6, Corners7,
DirectX::Internal::FastIntersectFrustumPlane( Corners0, Corners1, Corners2, Corners3,
Corners4, Corners5, Corners6, Corners7,
Plane2, Outside, Inside );
AnyOutside = XMVectorOrInt( AnyOutside, Outside );
AllInside = XMVectorAndInt( AllInside, Inside );
DirectX::Internal::FastIntersectFrustumPlane( Corners0, Corners1, Corners2, Corners3,
Corners4, Corners5, Corners6, Corners7,
DirectX::Internal::FastIntersectFrustumPlane( Corners0, Corners1, Corners2, Corners3,
Corners4, Corners5, Corners6, Corners7,
Plane3, Outside, Inside );
AnyOutside = XMVectorOrInt( AnyOutside, Outside );
AllInside = XMVectorAndInt( AllInside, Inside );
DirectX::Internal::FastIntersectFrustumPlane( Corners0, Corners1, Corners2, Corners3,
Corners4, Corners5, Corners6, Corners7,
DirectX::Internal::FastIntersectFrustumPlane( Corners0, Corners1, Corners2, Corners3,
Corners4, Corners5, Corners6, Corners7,
Plane4, Outside, Inside );
AnyOutside = XMVectorOrInt( AnyOutside, Outside );
AllInside = XMVectorAndInt( AllInside, Inside );
DirectX::Internal::FastIntersectFrustumPlane( Corners0, Corners1, Corners2, Corners3,
Corners4, Corners5, Corners6, Corners7,
DirectX::Internal::FastIntersectFrustumPlane( Corners0, Corners1, Corners2, Corners3,
Corners4, Corners5, Corners6, Corners7,
Plane5, Outside, Inside );
AnyOutside = XMVectorOrInt( AnyOutside, Outside );
@ -4171,7 +4171,7 @@ inline ContainmentType XM_CALLCONV BoundingFrustum::ContainedBy( FXMVECTOR Plane
//-----------------------------------------------------------------------------
// Build the 6 frustum planes from a frustum.
//
// The intended use for these routines is for fast culling to a view frustum.
// The intended use for these routines is for fast culling to a view frustum.
// When the volume being tested against a view frustum is small relative to the
// view frustum it is usually either inside all six planes of the frustum
// (CONTAINS) or outside one of the planes of the frustum (DISJOINT). If neither
@ -4295,12 +4295,12 @@ namespace TriangleTests
{
//-----------------------------------------------------------------------------
// Compute the intersection of a ray (Origin, Direction) with a triangle
// (V0, V1, V2). Return true if there is an intersection and also set *pDist
// Compute the intersection of a ray (Origin, Direction) with a triangle
// (V0, V1, V2). Return true if there is an intersection and also set *pDist
// to the distance along the ray to the intersection.
//
// The algorithm is based on Moller, Tomas and Trumbore, "Fast, Minimum Storage
// Ray-Triangle Intersection", Journal of Graphics Tools, vol. 2, no. 1,
//
// The algorithm is based on Moller, Tomas and Trumbore, "Fast, Minimum Storage
// Ray-Triangle Intersection", Journal of Graphics Tools, vol. 2, no. 1,
// pp 21-28, 1997.
//-----------------------------------------------------------------------------
_Use_decl_annotations_
@ -4404,14 +4404,14 @@ inline bool XM_CALLCONV Intersects( FXMVECTOR Origin, FXMVECTOR Direction, FXMVE
//-----------------------------------------------------------------------------
// Test if two triangles intersect.
//
// The final test of algorithm is based on Shen, Heng, and Tang, "A Fast
// Triangle-Triangle Overlap Test Using Signed Distances", Journal of Graphics
// Tools, vol. 8, no. 1, pp 17-23, 2003 and Guigue and Devillers, "Fast and
// Robust Triangle-Triangle Overlap Test Using Orientation Predicates", Journal
// The final test of algorithm is based on Shen, Heng, and Tang, "A Fast
// Triangle-Triangle Overlap Test Using Signed Distances", Journal of Graphics
// Tools, vol. 8, no. 1, pp 17-23, 2003 and Guigue and Devillers, "Fast and
// Robust Triangle-Triangle Overlap Test Using Orientation Predicates", Journal
// of Graphics Tools, vol. 8, no. 1, pp 25-32, 2003.
//
// The final test could be considered an edge-edge separating plane test with
// the 9 possible cases narrowed down to the only two pairs of edges that can
// the 9 possible cases narrowed down to the only two pairs of edges that can
// actaully result in a seperation.
//-----------------------------------------------------------------------------
_Use_decl_annotations_
@ -4548,7 +4548,7 @@ inline bool XM_CALLCONV Intersects( FXMVECTOR A0, FXMVECTOR A1, FXMVECTOR A2, GX
//
// Find the single vertex of A and B (ie the vertex on the opposite side
// of the plane from the other two) and reorder the edges so we can compute
// of the plane from the other two) and reorder the edges so we can compute
// the signed edge/edge distances.
//
// if ( (V0 >= 0 && V1 < 0 && V2 < 0) ||
@ -4557,7 +4557,7 @@ inline bool XM_CALLCONV Intersects( FXMVECTOR A0, FXMVECTOR A1, FXMVECTOR A2, GX
// (V0 < 0 && V1 >= 0 && V2 >= 0) ) then V0 is singular;
//
// If our singular vertex is not on the positive side of the plane we reverse
// the triangle winding so that the overlap comparisons will compare the
// the triangle winding so that the overlap comparisons will compare the
// correct edges with the correct signs.
//
XMVECTOR ADistIsLessEqual = XMVectorOrInt( ADistIsLess, ADistIsZero );

48
Inc/DirectXMathConvert.inl
View File

@ -615,7 +615,7 @@ inline XMVECTOR XM_CALLCONV XMLoadUInt3
// For only the ones that are too big, add the fixup
vMask = _mm_and_ps(_mm_castsi128_ps(iMask),g_XMFixUnsigned);
vResult = _mm_add_ps(vResult,vMask);
return vResult;
return vResult;
#endif
}
@ -828,7 +828,7 @@ inline XMMATRIX XM_CALLCONV XMLoadFloat3x3
__m128 T2 = _mm_unpacklo_ps( V2, Z );
__m128 T3 = _mm_shuffle_ps( V3, T2, _MM_SHUFFLE( 0, 1, 0, 0 ) );
__m128 T4 = _mm_movehl_ps( T2, T3 );
__m128 T5 = _mm_movehl_ps( Z, T1 );
__m128 T5 = _mm_movehl_ps( Z, T1 );
XMMATRIX M;
M.r[0] = _mm_movelh_ps( V1, T1 );
@ -887,7 +887,7 @@ inline XMMATRIX XM_CALLCONV XMLoadFloat4x3
M.r[3] = vsetq_lane_f32( 1.f, T3, 3 );
return M;
#elif defined(_XM_SSE_INTRINSICS_)
// Use unaligned load instructions to
// Use unaligned load instructions to
// load the 12 floats
// vTemp1 = x1,y1,z1,x2
XMVECTOR vTemp1 = _mm_loadu_ps(&pSource->m[0][0]);
@ -968,7 +968,7 @@ inline XMMATRIX XM_CALLCONV XMLoadFloat4x3A
M.r[3] = vsetq_lane_f32( 1.f, T3, 3 );
return M;
#elif defined(_XM_SSE_INTRINSICS_)
// Use aligned load instructions to
// Use aligned load instructions to
// load the 12 floats
// vTemp1 = x1,y1,z1,x2
XMVECTOR vTemp1 = _mm_load_ps(&pSource->m[0][0]);
@ -1306,7 +1306,7 @@ inline void XM_CALLCONV XMStoreFloat
_Use_decl_annotations_
inline void XM_CALLCONV XMStoreInt2
(
uint32_t* pDestination,
uint32_t* pDestination,
FXMVECTOR V
)
{
@ -1328,7 +1328,7 @@ inline void XM_CALLCONV XMStoreInt2
_Use_decl_annotations_
inline void XM_CALLCONV XMStoreInt2A
(
uint32_t* pDestination,
uint32_t* pDestination,
FXMVECTOR V
)
{
@ -1349,7 +1349,7 @@ inline void XM_CALLCONV XMStoreInt2A
_Use_decl_annotations_
inline void XM_CALLCONV XMStoreFloat2
(
XMFLOAT2* pDestination,
XMFLOAT2* pDestination,
FXMVECTOR V
)
{
@ -1371,7 +1371,7 @@ inline void XM_CALLCONV XMStoreFloat2
_Use_decl_annotations_
inline void XM_CALLCONV XMStoreFloat2A
(
XMFLOAT2A* pDestination,
XMFLOAT2A* pDestination,
FXMVECTOR V
)
{
@ -1465,7 +1465,7 @@ inline void XM_CALLCONV XMStoreUInt2
_Use_decl_annotations_
inline void XM_CALLCONV XMStoreInt3
(
uint32_t* pDestination,
uint32_t* pDestination,
FXMVECTOR V
)
{
@ -1491,7 +1491,7 @@ inline void XM_CALLCONV XMStoreInt3
_Use_decl_annotations_
inline void XM_CALLCONV XMStoreInt3A
(
uint32_t* pDestination,
uint32_t* pDestination,
FXMVECTOR V
)
{
@ -1516,7 +1516,7 @@ inline void XM_CALLCONV XMStoreInt3A
_Use_decl_annotations_
inline void XM_CALLCONV XMStoreFloat3
(
XMFLOAT3* pDestination,
XMFLOAT3* pDestination,
FXMVECTOR V
)
{
@ -1542,7 +1542,7 @@ inline void XM_CALLCONV XMStoreFloat3
_Use_decl_annotations_
inline void XM_CALLCONV XMStoreFloat3A
(
XMFLOAT3A* pDestination,
XMFLOAT3A* pDestination,
FXMVECTOR V
)
{
@ -1648,7 +1648,7 @@ inline void XM_CALLCONV XMStoreUInt3
_Use_decl_annotations_
inline void XM_CALLCONV XMStoreInt4
(
uint32_t* pDestination,
uint32_t* pDestination,
FXMVECTOR V
)
{
@ -1669,7 +1669,7 @@ inline void XM_CALLCONV XMStoreInt4
_Use_decl_annotations_
inline void XM_CALLCONV XMStoreInt4A
(
uint32_t* pDestination,
uint32_t* pDestination,
FXMVECTOR V
)
{
@ -1691,7 +1691,7 @@ inline void XM_CALLCONV XMStoreInt4A
_Use_decl_annotations_
inline void XM_CALLCONV XMStoreFloat4
(
XMFLOAT4* pDestination,
XMFLOAT4* pDestination,
FXMVECTOR V
)
{
@ -1712,7 +1712,7 @@ inline void XM_CALLCONV XMStoreFloat4
_Use_decl_annotations_
inline void XM_CALLCONV XMStoreFloat4A
(
XMFLOAT4A* pDestination,
XMFLOAT4A* pDestination,
FXMVECTOR V
)
{
@ -1803,8 +1803,8 @@ inline void XM_CALLCONV XMStoreUInt4
_Use_decl_annotations_
inline void XM_CALLCONV XMStoreFloat3x3
(
XMFLOAT3X3* pDestination,
FXMMATRIX M
XMFLOAT3X3* pDestination,
FXMMATRIX M
)
{
assert(pDestination);
@ -1850,7 +1850,7 @@ inline void XM_CALLCONV XMStoreFloat3x3
_Use_decl_annotations_
inline void XM_CALLCONV XMStoreFloat4x3
(
XMFLOAT4X3* pDestination,
XMFLOAT4X3* pDestination,
FXMMATRIX M
)
{
@ -1905,8 +1905,8 @@ inline void XM_CALLCONV XMStoreFloat4x3
_Use_decl_annotations_
inline void XM_CALLCONV XMStoreFloat4x3A
(
XMFLOAT4X3A* pDestination,
FXMMATRIX M
XMFLOAT4X3A* pDestination,
FXMMATRIX M
)
{
assert(pDestination);
@ -2090,7 +2090,7 @@ inline void XM_CALLCONV XMStoreFloat3x4A
_Use_decl_annotations_
inline void XM_CALLCONV XMStoreFloat4x4
(
XMFLOAT4X4* pDestination,
XMFLOAT4X4* pDestination,
FXMMATRIX M
)
{
@ -2134,8 +2134,8 @@ inline void XM_CALLCONV XMStoreFloat4x4
_Use_decl_annotations_
inline void XM_CALLCONV XMStoreFloat4x4A
(
XMFLOAT4X4A* pDestination,
FXMMATRIX M
XMFLOAT4X4A* pDestination,
FXMMATRIX M
)
{
assert(pDestination);

200
Inc/DirectXMathMatrix.inl
View File

@ -216,7 +216,7 @@ inline bool XM_CALLCONV XMMatrixIsIdentity
// Perform a 4x4 matrix multiply by a 4x4 matrix
inline XMMATRIX XM_CALLCONV XMMatrixMultiply
(
FXMMATRIX M1,
FXMMATRIX M1,
CXMMATRIX M2
)
{
@ -386,7 +386,7 @@ inline XMMATRIX XM_CALLCONV XMMatrixMultiply
inline XMMATRIX XM_CALLCONV XMMatrixMultiplyTranspose
(
FXMMATRIX M1,
FXMMATRIX M1,
CXMMATRIX M2
)
{
@ -459,7 +459,7 @@ inline XMMATRIX XM_CALLCONV XMMatrixMultiplyTranspose
vZ = vmlaq_lane_f32(vX, M2.r[2], VH, 0);
vW = vmlaq_lane_f32(vY, M2.r[3], VH, 1);
float32x4_t r3 = vaddq_f32( vZ, vW );
// Transpose result
float32x4x2_t P0 = vzipq_f32( r0, r2 );
float32x4x2_t P1 = vzipq_f32( r1, r3 );
@ -652,7 +652,7 @@ inline XMMATRIX XM_CALLCONV XMMatrixTranspose
_Use_decl_annotations_
inline XMMATRIX XM_CALLCONV XMMatrixInverse
(
XMVECTOR* pDeterminant,
XMVECTOR* pDeterminant,
FXMMATRIX M
)
{
@ -718,7 +718,7 @@ inline XMMATRIX XM_CALLCONV XMMatrixInverse
V0[2] = XMVectorSwizzle<XM_SWIZZLE_W, XM_SWIZZLE_X, XM_SWIZZLE_W, XM_SWIZZLE_X>(MT.r[3]);
V1[2] = XMVectorPermute<XM_PERMUTE_0Z, XM_PERMUTE_1W, XM_PERMUTE_1Z, XM_PERMUTE_0Z>(D1, D2);
V0[3] = XMVectorSwizzle<XM_SWIZZLE_Y, XM_SWIZZLE_W, XM_SWIZZLE_X, XM_SWIZZLE_Z>(MT.r[2]);
V1[3] = XMVectorPermute<XM_PERMUTE_1W, XM_PERMUTE_0X, XM_PERMUTE_0W, XM_PERMUTE_1Z>(D1, D2);
V1[3] = XMVectorPermute<XM_PERMUTE_1W, XM_PERMUTE_0X, XM_PERMUTE_0W, XM_PERMUTE_1Z>(D1, D2);
XMVECTOR C1 = XMVectorNegativeMultiplySubtract(V0[0], V1[0], C0);
C0 = XMVectorMultiplyAdd(V0[0], V1[0], C0);
@ -959,7 +959,7 @@ inline XMVECTOR XM_CALLCONV XMMatrixDeterminant
} \
} \
}
#define XM3_DECOMP_EPSILON 0.0001f
_Use_decl_annotations_
@ -998,9 +998,9 @@ inline bool XM_CALLCONV XMMatrixDecompose
auto pfScales = reinterpret_cast<float *>(outScale);
size_t a, b, c;
XMVectorGetXPtr(&pfScales[0],XMVector3Length(ppvBasis[0][0]));
XMVectorGetXPtr(&pfScales[1],XMVector3Length(ppvBasis[1][0]));
XMVectorGetXPtr(&pfScales[2],XMVector3Length(ppvBasis[2][0]));
XMVectorGetXPtr(&pfScales[0],XMVector3Length(ppvBasis[0][0]));
XMVectorGetXPtr(&pfScales[1],XMVector3Length(ppvBasis[1][0]));
XMVectorGetXPtr(&pfScales[2],XMVector3Length(ppvBasis[2][0]));
pfScales[3] = 0.f;
XM3RANKDECOMPOSE(a, b, c, pfScales[0], pfScales[1], pfScales[2])
@ -1031,7 +1031,7 @@ inline bool XM_CALLCONV XMMatrixDecompose
{
ppvBasis[c][0] = XMVector3Cross(ppvBasis[a][0],ppvBasis[b][0]);
}
ppvBasis[c][0] = XMVector3Normalize(ppvBasis[c][0]);
float fDet = XMVectorGetX(XMMatrixDeterminant(matTemp));
@ -1108,8 +1108,8 @@ inline XMMATRIX XM_CALLCONV XMMatrixSet
inline XMMATRIX XM_CALLCONV XMMatrixTranslation
(
float OffsetX,
float OffsetY,
float OffsetX,
float OffsetY,
float OffsetZ
)
{
@ -1193,8 +1193,8 @@ inline XMMATRIX XM_CALLCONV XMMatrixTranslationFromVector
inline XMMATRIX XM_CALLCONV XMMatrixScaling
(
float ScaleX,
float ScaleY,
float ScaleX,
float ScaleY,
float ScaleZ
)
{
@ -1296,7 +1296,7 @@ inline XMMATRIX XM_CALLCONV XMMatrixRotationX
)
{
#if defined(_XM_NO_INTRINSICS_)
float fSinAngle;
float fCosAngle;
XMScalarSinCos(&fSinAngle, &fCosAngle, Angle);
@ -1372,7 +1372,7 @@ inline XMMATRIX XM_CALLCONV XMMatrixRotationY
)
{
#if defined(_XM_NO_INTRINSICS_)
float fSinAngle;
float fCosAngle;
XMScalarSinCos(&fSinAngle, &fCosAngle, Angle);
@ -1448,7 +1448,7 @@ inline XMMATRIX XM_CALLCONV XMMatrixRotationZ
)
{
#if defined(_XM_NO_INTRINSICS_)
float fSinAngle;
float fCosAngle;
XMScalarSinCos(&fSinAngle, &fCosAngle, Angle);
@ -1520,8 +1520,8 @@ inline XMMATRIX XM_CALLCONV XMMatrixRotationZ
inline XMMATRIX XM_CALLCONV XMMatrixRotationRollPitchYaw
(
float Pitch,
float Yaw,
float Pitch,
float Yaw,
float Roll
)
{
@ -1544,7 +1544,7 @@ inline XMMATRIX XM_CALLCONV XMMatrixRotationRollPitchYawFromVector
inline XMMATRIX XM_CALLCONV XMMatrixRotationNormal
(
FXMVECTOR NormalAxis,
FXMVECTOR NormalAxis,
float Angle
)
{
@ -1634,7 +1634,7 @@ inline XMMATRIX XM_CALLCONV XMMatrixRotationNormal
inline XMMATRIX XM_CALLCONV XMMatrixRotationAxis
(
FXMVECTOR Axis,
FXMVECTOR Axis,
float Angle
)
{
@ -1735,11 +1735,11 @@ inline XMMATRIX XM_CALLCONV XMMatrixRotationQuaternion
inline XMMATRIX XM_CALLCONV XMMatrixTransformation2D
(
FXMVECTOR ScalingOrigin,
float ScalingOrientation,
FXMVECTOR Scaling,
FXMVECTOR RotationOrigin,
float Rotation,
FXMVECTOR ScalingOrigin,
float ScalingOrientation,
FXMVECTOR Scaling,
FXMVECTOR RotationOrigin,
float Rotation,
GXMVECTOR Translation
)
{
@ -1774,11 +1774,11 @@ inline XMMATRIX XM_CALLCONV XMMatrixTransformation2D
inline XMMATRIX XM_CALLCONV XMMatrixTransformation
(
FXMVECTOR ScalingOrigin,
FXMVECTOR ScalingOrientationQuaternion,
FXMVECTOR Scaling,
GXMVECTOR RotationOrigin,
HXMVECTOR RotationQuaternion,
FXMVECTOR ScalingOrigin,
FXMVECTOR ScalingOrientationQuaternion,
FXMVECTOR Scaling,
GXMVECTOR RotationOrigin,
HXMVECTOR RotationQuaternion,
HXMVECTOR Translation
)
{
@ -1812,9 +1812,9 @@ inline XMMATRIX XM_CALLCONV XMMatrixTransformation
inline XMMATRIX XM_CALLCONV XMMatrixAffineTransformation2D
(
FXMVECTOR Scaling,
FXMVECTOR RotationOrigin,
float Rotation,
FXMVECTOR Scaling,
FXMVECTOR RotationOrigin,
float Rotation,
FXMVECTOR Translation
)
{
@ -1839,9 +1839,9 @@ inline XMMATRIX XM_CALLCONV XMMatrixAffineTransformation2D
inline XMMATRIX XM_CALLCONV XMMatrixAffineTransformation
(
FXMVECTOR Scaling,
FXMVECTOR RotationOrigin,
FXMVECTOR RotationQuaternion,
FXMVECTOR Scaling,
FXMVECTOR RotationOrigin,
FXMVECTOR RotationQuaternion,
GXMVECTOR Translation
)
{
@ -1893,7 +1893,7 @@ inline XMMATRIX XM_CALLCONV XMMatrixReflect
inline XMMATRIX XM_CALLCONV XMMatrixShadow
(
FXMVECTOR ShadowPlane,
FXMVECTOR ShadowPlane,
FXMVECTOR LightPosition
)
{
@ -1928,8 +1928,8 @@ inline XMMATRIX XM_CALLCONV XMMatrixShadow
inline XMMATRIX XM_CALLCONV XMMatrixLookAtLH
(
FXMVECTOR EyePosition,
FXMVECTOR FocusPosition,
FXMVECTOR EyePosition,
FXMVECTOR FocusPosition,
FXMVECTOR UpDirection
)
{
@ -1941,8 +1941,8 @@ inline XMMATRIX XM_CALLCONV XMMatrixLookAtLH
inline XMMATRIX XM_CALLCONV XMMatrixLookAtRH
(
FXMVECTOR EyePosition,
FXMVECTOR FocusPosition,
FXMVECTOR EyePosition,
FXMVECTOR FocusPosition,
FXMVECTOR UpDirection
)
{
@ -1954,8 +1954,8 @@ inline XMMATRIX XM_CALLCONV XMMatrixLookAtRH
inline XMMATRIX XM_CALLCONV XMMatrixLookToLH
(
FXMVECTOR EyePosition,
FXMVECTOR EyeDirection,
FXMVECTOR EyePosition,
FXMVECTOR EyeDirection,
FXMVECTOR UpDirection
)
{
@ -1992,8 +1992,8 @@ inline XMMATRIX XM_CALLCONV XMMatrixLookToLH
inline XMMATRIX XM_CALLCONV XMMatrixLookToRH
(
FXMVECTOR EyePosition,
FXMVECTOR EyeDirection,
FXMVECTOR EyePosition,
FXMVECTOR EyeDirection,
FXMVECTOR UpDirection
)
{
@ -2010,9 +2010,9 @@ inline XMMATRIX XM_CALLCONV XMMatrixLookToRH
inline XMMATRIX XM_CALLCONV XMMatrixPerspectiveLH
(
float ViewWidth,
float ViewHeight,
float NearZ,
float ViewWidth,
float ViewHeight,
float NearZ,
float FarZ
)
{
@ -2042,7 +2042,7 @@ inline XMMATRIX XM_CALLCONV XMMatrixPerspectiveLH
M.m[2][2] = fRange;
M.m[2][3] = 1.0f;
M.m[3][0] = 0.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;
@ -2071,7 +2071,7 @@ inline XMMATRIX XM_CALLCONV XMMatrixPerspectiveLH
};
// Copy from memory to SSE register
XMVECTOR vValues = rMem;
XMVECTOR vTemp = _mm_setzero_ps();
XMVECTOR vTemp = _mm_setzero_ps();
// Copy x only
vTemp = _mm_move_ss(vTemp,vValues);
// TwoNearZ / ViewWidth,0,0,0
@ -2097,9 +2097,9 @@ inline XMMATRIX XM_CALLCONV XMMatrixPerspectiveLH
inline XMMATRIX XM_CALLCONV XMMatrixPerspectiveRH
(
float ViewWidth,
float ViewHeight,
float NearZ,
float ViewWidth,
float ViewHeight,
float NearZ,
float FarZ
)
{
@ -2159,7 +2159,7 @@ inline XMMATRIX XM_CALLCONV XMMatrixPerspectiveRH
};
// Copy from memory to SSE register
XMVECTOR vValues = rMem;
XMVECTOR vTemp = _mm_setzero_ps();
XMVECTOR vTemp = _mm_setzero_ps();
// Copy x only
vTemp = _mm_move_ss(vTemp,vValues);
// TwoNearZ / ViewWidth,0,0,0
@ -2185,9 +2185,9 @@ inline XMMATRIX XM_CALLCONV XMMatrixPerspectiveRH
inline XMMATRIX XM_CALLCONV XMMatrixPerspectiveFovLH
(
float FovAngleY,
float AspectRatio,
float NearZ,
float FovAngleY,
float AspectRatio,
float NearZ,
float FarZ
)
{
@ -2260,7 +2260,7 @@ inline XMMATRIX XM_CALLCONV XMMatrixPerspectiveFovLH
};
// Copy from memory to SSE register
XMVECTOR vValues = rMem;
XMVECTOR vTemp = _mm_setzero_ps();
XMVECTOR vTemp = _mm_setzero_ps();
// Copy x only
vTemp = _mm_move_ss(vTemp,vValues);
// CosFov / SinFov,0,0,0
@ -2287,9 +2287,9 @@ inline XMMATRIX XM_CALLCONV XMMatrixPerspectiveFovLH
inline XMMATRIX XM_CALLCONV XMMatrixPerspectiveFovRH
(
float FovAngleY,
float AspectRatio,
float NearZ,
float FovAngleY,
float AspectRatio,
float NearZ,
float FarZ
)
{
@ -2360,7 +2360,7 @@ inline XMMATRIX XM_CALLCONV XMMatrixPerspectiveFovRH
};
// Copy from memory to SSE register
XMVECTOR vValues = rMem;
XMVECTOR vTemp = _mm_setzero_ps();
XMVECTOR vTemp = _mm_setzero_ps();
// Copy x only
vTemp = _mm_move_ss(vTemp,vValues);
// CosFov / SinFov,0,0,0
@ -2387,11 +2387,11 @@ inline XMMATRIX XM_CALLCONV XMMatrixPerspectiveFovRH
inline XMMATRIX XM_CALLCONV XMMatrixPerspectiveOffCenterLH
(
float ViewLeft,
float ViewRight,
float ViewBottom,
float ViewTop,
float NearZ,
float ViewLeft,
float ViewRight,
float ViewBottom,
float ViewTop,
float NearZ,
float FarZ
)
{
@ -2439,7 +2439,7 @@ inline XMMATRIX XM_CALLCONV XMMatrixPerspectiveOffCenterLH
XMMATRIX M;
M.r[0] = vsetq_lane_f32( TwoNearZ * ReciprocalWidth, Zero, 0 );
M.r[1] = vsetq_lane_f32( TwoNearZ * ReciprocalHeight, Zero, 1 );
M.r[2] = XMVectorSet(-(ViewLeft + ViewRight) * ReciprocalWidth,
M.r[2] = XMVectorSet(-(ViewLeft + ViewRight) * ReciprocalWidth,
-(ViewTop + ViewBottom) * ReciprocalHeight,
fRange,
1.0f);
@ -2460,7 +2460,7 @@ inline XMMATRIX XM_CALLCONV XMMatrixPerspectiveOffCenterLH
};
// Copy from memory to SSE register
XMVECTOR vValues = rMem;
XMVECTOR vTemp = _mm_setzero_ps();
XMVECTOR vTemp = _mm_setzero_ps();
// Copy x only
vTemp = _mm_move_ss(vTemp,vValues);
// TwoNearZ*ReciprocalWidth,0,0,0
@ -2485,11 +2485,11 @@ inline XMMATRIX XM_CALLCONV XMMatrixPerspectiveOffCenterLH
inline XMMATRIX XM_CALLCONV XMMatrixPerspectiveOffCenterRH
(
float ViewLeft,
float ViewRight,
float ViewBottom,
float ViewTop,
float NearZ,
float ViewLeft,
float ViewRight,
float ViewBottom,
float ViewTop,
float NearZ,
float FarZ
)
{
@ -2537,7 +2537,7 @@ inline XMMATRIX XM_CALLCONV XMMatrixPerspectiveOffCenterRH
XMMATRIX M;
M.r[0] = vsetq_lane_f32( TwoNearZ * ReciprocalWidth, Zero, 0 );
M.r[1] = vsetq_lane_f32( TwoNearZ * ReciprocalHeight, Zero, 1 );
M.r[2] = XMVectorSet((ViewLeft + ViewRight) * ReciprocalWidth,
M.r[2] = XMVectorSet((ViewLeft + ViewRight) * ReciprocalWidth,
(ViewTop + ViewBottom) * ReciprocalHeight,
fRange,
-1.0f);
@ -2558,7 +2558,7 @@ inline XMMATRIX XM_CALLCONV XMMatrixPerspectiveOffCenterRH
};
// Copy from memory to SSE register
XMVECTOR vValues = rMem;
XMVECTOR vTemp = _mm_setzero_ps();
XMVECTOR vTemp = _mm_setzero_ps();
// Copy x only
vTemp = _mm_move_ss(vTemp,vValues);
// TwoNearZ*ReciprocalWidth,0,0,0
@ -2583,9 +2583,9 @@ inline XMMATRIX XM_CALLCONV XMMatrixPerspectiveOffCenterRH
inline XMMATRIX XM_CALLCONV XMMatrixOrthographicLH
(
float ViewWidth,
float ViewHeight,
float NearZ,
float ViewWidth,
float ViewHeight,
float NearZ,
float FarZ
)
{
@ -2641,7 +2641,7 @@ inline XMMATRIX XM_CALLCONV XMMatrixOrthographicLH
};
// Copy from memory to SSE register
XMVECTOR vValues = rMem;
XMVECTOR vTemp = _mm_setzero_ps();
XMVECTOR vTemp = _mm_setzero_ps();
// Copy x only
vTemp = _mm_move_ss(vTemp,vValues);
// 2.0f / ViewWidth,0,0,0
@ -2667,9 +2667,9 @@ inline XMMATRIX XM_CALLCONV XMMatrixOrthographicLH
inline XMMATRIX XM_CALLCONV XMMatrixOrthographicRH
(
float ViewWidth,
float ViewHeight,
float NearZ,
float ViewWidth,
float ViewHeight,
float NearZ,
float FarZ
)
{
@ -2725,7 +2725,7 @@ inline XMMATRIX XM_CALLCONV XMMatrixOrthographicRH
};
// Copy from memory to SSE register
XMVECTOR vValues = rMem;
XMVECTOR vTemp = _mm_setzero_ps();
XMVECTOR vTemp = _mm_setzero_ps();
// Copy x only
vTemp = _mm_move_ss(vTemp,vValues);
// 2.0f / ViewWidth,0,0,0
@ -2751,11 +2751,11 @@ inline XMMATRIX XM_CALLCONV XMMatrixOrthographicRH
inline XMMATRIX XM_CALLCONV XMMatrixOrthographicOffCenterLH
(
float ViewLeft,
float ViewRight,
float ViewBottom,
float ViewTop,
float NearZ,
float ViewLeft,
float ViewRight,
float ViewBottom,
float ViewTop,
float NearZ,
float FarZ
)
{
@ -2800,7 +2800,7 @@ inline XMMATRIX XM_CALLCONV XMMatrixOrthographicOffCenterLH
M.r[0] = vsetq_lane_f32( ReciprocalWidth + ReciprocalWidth, Zero, 0 );
M.r[1] = vsetq_lane_f32( ReciprocalHeight + ReciprocalHeight, Zero, 1 );
M.r[2] = vsetq_lane_f32( fRange, Zero, 2 );
M.r[3] = XMVectorSet(-(ViewLeft + ViewRight) * ReciprocalWidth,
M.r[3] = XMVectorSet(-(ViewLeft + ViewRight) * ReciprocalWidth,
-(ViewTop + ViewBottom) * ReciprocalHeight,
-fRange * NearZ,
1.0f);
@ -2825,7 +2825,7 @@ inline XMMATRIX XM_CALLCONV XMMatrixOrthographicOffCenterLH
};
// Copy from memory to SSE register
XMVECTOR vValues = rMem;
XMVECTOR vTemp = _mm_setzero_ps();
XMVECTOR vTemp = _mm_setzero_ps();
// Copy x only
vTemp = _mm_move_ss(vTemp,vValues);
// fReciprocalWidth*2,0,0,0
@ -2851,11 +2851,11 @@ inline XMMATRIX XM_CALLCONV XMMatrixOrthographicOffCenterLH
inline XMMATRIX XM_CALLCONV XMMatrixOrthographicOffCenterRH
(
float ViewLeft,
float ViewRight,
float ViewBottom,
float ViewTop,
float NearZ,
float ViewLeft,
float ViewRight,
float ViewBottom,
float ViewTop,
float NearZ,
float FarZ
)
{
@ -2885,7 +2885,7 @@ inline XMMATRIX XM_CALLCONV XMMatrixOrthographicOffCenterRH
M.m[2][2] = fRange;
M.m[2][3] = 0.0f;
M.r[3] = XMVectorSet(-(ViewLeft + ViewRight) * ReciprocalWidth,
M.r[3] = XMVectorSet(-(ViewLeft + ViewRight) * ReciprocalWidth,
-(ViewTop + ViewBottom) * ReciprocalHeight,
fRange * NearZ,
1.0f);
@ -2900,7 +2900,7 @@ inline XMMATRIX XM_CALLCONV XMMatrixOrthographicOffCenterRH
M.r[0] = vsetq_lane_f32( ReciprocalWidth + ReciprocalWidth, Zero, 0 );
M.r[1] = vsetq_lane_f32( ReciprocalHeight + ReciprocalHeight, Zero, 1 );
M.r[2] = vsetq_lane_f32( fRange, Zero, 2 );
M.r[3] = XMVectorSet(-(ViewLeft + ViewRight) * ReciprocalWidth,
M.r[3] = XMVectorSet(-(ViewLeft + ViewRight) * ReciprocalWidth,
-(ViewTop + ViewBottom) * ReciprocalHeight,
fRange * NearZ,
1.0f);
@ -2925,7 +2925,7 @@ inline XMMATRIX XM_CALLCONV XMMatrixOrthographicOffCenterRH
};
// Copy from memory to SSE register
XMVECTOR vValues = rMem;
XMVECTOR vTemp = _mm_setzero_ps();
XMVECTOR vTemp = _mm_setzero_ps();
// Copy x only
vTemp = _mm_move_ss(vTemp,vValues);
// fReciprocalWidth*2,0,0,0

16
Inc/DirectXMathMisc.inl
View File

@ -784,7 +784,7 @@ inline XMVECTOR XM_CALLCONV XMQuaternionRotationMatrix
// z^2 >= w^2 equivalent to r11 + r00 <= 0
XMVECTOR r11pr00 = vaddq_f32(r11, r00);
XMVECTOR z2gew2 = vcleq_f32(r11pr00, g_XMZero);
// x^2 + y^2 >= z^2 + w^2 equivalent to r22 <= 0
XMVECTOR x2py2gez2pw2 = vcleq_f32(r22, g_XMZero);
@ -1258,7 +1258,7 @@ inline XMFLOAT4* XM_CALLCONV XMPlaneTransformStream
(
XMFLOAT4* pOutputStream,
size_t OutputStride,
const XMFLOAT4* pInputStream,
const XMFLOAT4* pInputStream,
size_t InputStride,
size_t PlaneCount,
FXMMATRIX M
@ -1554,12 +1554,12 @@ inline XMVECTOR XM_CALLCONV XMColorRGBToHSL( FXMVECTOR rgb )
if ( XMVector3Greater( l, g_XMOneHalf ) )
{
// d / (2-max-min)
s = XMVectorDivide( d, XMVectorSubtract( g_XMTwo, d2 ) );
s = XMVectorDivide( d, XMVectorSubtract( g_XMTwo, d2 ) );
}
else
{
// d / (max+min)
s = XMVectorDivide( d, d2 );
s = XMVectorDivide( d, d2 );
}
if ( XMVector3Equal( r, max ) )
@ -1599,7 +1599,7 @@ inline XMVECTOR XM_CALLCONV XMColorHue2Clr( FXMVECTOR p, FXMVECTOR q, FXMVECTOR
{
static const XMVECTORF32 oneSixth = { { { 1.0f / 6.0f, 1.0f / 6.0f, 1.0f / 6.0f, 1.0f / 6.0f } } };
static const XMVECTORF32 twoThirds = { { { 2.0f / 3.0f, 2.0f / 3.0f, 2.0f / 3.0f, 2.0f / 3.0f } } };
XMVECTOR t = h;
if ( XMVector3Less( t, g_XMZero ) )
@ -1842,7 +1842,7 @@ inline XMVECTOR XM_CALLCONV XMColorYUVToRGB_HD( FXMVECTOR yuv )
{
static const XMVECTORF32 Scale1 = { { { 0.0f, -0.2153f, 2.1324f, 0.0f } } };
static const XMVECTORF32 Scale2 = { { { 1.2803f, -0.3806f, 0.0f, 0.0f } } };
XMMATRIX M( g_XMOne, Scale1, Scale2, g_XMZero );
XMVECTOR clr = XMVector3Transform( yuv, M );
@ -2010,7 +2010,7 @@ inline bool XMVerifyCPUSupport()
return false; // No SSE3/SSE4.1 support
#elif defined(_XM_SSE3_INTRINSICS_)
if (!(CPUInfo[2] & 0x1))
return false; // No SSE3 support
return false; // No SSE3 support
#endif
// The x64 processor model requires SSE2 support, but no harm in checking
@ -2093,7 +2093,7 @@ inline XMVECTOR XM_CALLCONV XMFresnelTerm
// Calc G-C and G+C
XMVECTOR GAddC = _mm_add_ps(G,CosIncidentAngle);
XMVECTOR GSubC = _mm_sub_ps(G,CosIncidentAngle);
// Perform the term (0.5f *(g - c)^2) / (g + c)^2
// Perform the term (0.5f *(g - c)^2) / (g + c)^2
XMVECTOR vResult = _mm_mul_ps(GSubC,GSubC);
vTemp = _mm_mul_ps(GAddC,GAddC);
vResult = _mm_mul_ps(vResult,g_XMOneHalf);

870
Inc/DirectXMathVector.inl
View File

File diff suppressed because it is too large Load Diff

38
Inc/DirectXPackedVector.h
View File

@ -13,7 +13,7 @@
namespace DirectX
{
namespace PackedVector
{
@ -63,7 +63,7 @@ struct XMCOLOR
};
//------------------------------------------------------------------------------
// 16 bit floating point number consisting of a sign bit, a 5 bit biased
// 16 bit floating point number consisting of a sign bit, a 5 bit biased
// exponent, and a 10 bit mantissa
typedef uint16_t HALF;
@ -619,9 +619,9 @@ struct XMUSHORT4
//------------------------------------------------------------------------------
// 4D Vector; 10-10-10-2 bit normalized components packed into a 32 bit integer
// The normalized 4D Vector is packed into 32 bits as follows: a 2 bit unsigned,
// normalized integer for the w component and 10 bit signed, normalized
// integers for the z, y, and x components. The w component is stored in the
// The normalized 4D Vector is packed into 32 bits as follows: a 2 bit unsigned,
// normalized integer for the w component and 10 bit signed, normalized
// integers for the z, y, and x components. The w component is stored in the
// most significant bits and the x component in the least significant bits
// (W2Z10Y10X10): [32] wwzzzzzz zzzzyyyy yyyyyyxx xxxxxxxx [0]
struct XMXDECN4
@ -657,8 +657,8 @@ struct XMXDECN4
// 4D Vector; 10-10-10-2 bit components packed into a 32 bit integer
// The normalized 4D Vector is packed into 32 bits as follows: a 2 bit unsigned
// integer for the w component and 10 bit signed integers for the
// z, y, and x components. The w component is stored in the
// integer for the w component and 10 bit signed integers for the
// z, y, and x components. The w component is stored in the
// most significant bits and the x component in the least significant bits
// (W2Z10Y10X10): [32] wwzzzzzz zzzzyyyy yyyyyyxx xxxxxxxx [0]
struct XM_DEPRECATED XMXDEC4
@ -693,9 +693,9 @@ struct XM_DEPRECATED XMXDEC4
};
// 4D Vector; 10-10-10-2 bit normalized components packed into a 32 bit integer
// The normalized 4D Vector is packed into 32 bits as follows: a 2 bit signed,
// normalized integer for the w component and 10 bit signed, normalized
// integers for the z, y, and x components. The w component is stored in the
// The normalized 4D Vector is packed into 32 bits as follows: a 2 bit signed,
// normalized integer for the w component and 10 bit signed, normalized
// integers for the z, y, and x components. The w component is stored in the
// most significant bits and the x component in the least significant bits
// (W2Z10Y10X10): [32] wwzzzzzz zzzzyyyy yyyyyyxx xxxxxxxx [0]
struct XM_DEPRECATED XMDECN4
@ -730,9 +730,9 @@ struct XM_DEPRECATED XMDECN4
};
// 4D Vector; 10-10-10-2 bit components packed into a 32 bit integer
// The 4D Vector is packed into 32 bits as follows: a 2 bit signed,
// integer for the w component and 10 bit signed integers for the
// z, y, and x components. The w component is stored in the
// The 4D Vector is packed into 32 bits as follows: a 2 bit signed,
// integer for the w component and 10 bit signed integers for the
// z, y, and x components. The w component is stored in the
// most significant bits and the x component in the least significant bits
// (W2Z10Y10X10): [32] wwzzzzzz zzzzyyyy yyyyyyxx xxxxxxxx [0]
struct XM_DEPRECATED XMDEC4
@ -767,9 +767,9 @@ struct XM_DEPRECATED XMDEC4
};
// 4D Vector; 10-10-10-2 bit normalized components packed into a 32 bit integer
// The normalized 4D Vector is packed into 32 bits as follows: a 2 bit unsigned,
// normalized integer for the w component and 10 bit unsigned, normalized
// integers for the z, y, and x components. The w component is stored in the
// The normalized 4D Vector is packed into 32 bits as follows: a 2 bit unsigned,
// normalized integer for the w component and 10 bit unsigned, normalized
// integers for the z, y, and x components. The w component is stored in the
// most significant bits and the x component in the least significant bits
// (W2Z10Y10X10): [32] wwzzzzzz zzzzyyyy yyyyyyxx xxxxxxxx [0]
struct XMUDECN4
@ -804,9 +804,9 @@ struct XMUDECN4
};
// 4D Vector; 10-10-10-2 bit components packed into a 32 bit integer
// The 4D Vector is packed into 32 bits as follows: a 2 bit unsigned,
// integer for the w component and 10 bit unsigned integers
// for the z, y, and x components. The w component is stored in the
// The 4D Vector is packed into 32 bits as follows: a 2 bit unsigned,
// integer for the w component and 10 bit unsigned integers
// for the z, y, and x components. The w component is stored in the
// most significant bits and the x component in the least significant bits
// (W2Z10Y10X10): [32] wwzzzzzz zzzzyyyy yyyyyyxx xxxxxxxx [0]
struct XMUDEC4

122
Inc/DirectXPackedVector.inl
View File

@ -78,10 +78,10 @@ inline float XMConvertHalfToFloat
_Use_decl_annotations_
inline float* XMConvertHalfToFloatStream
(
float* pOutputStream,
size_t OutputStride,
const HALF* pInputStream,
size_t InputStride,
float* pOutputStream,
size_t OutputStride,
const HALF* pInputStream,
size_t InputStride,
size_t HalfCount
)
{
@ -117,7 +117,7 @@ inline float* XMConvertHalfToFloatStream
__m128 FV = _mm_cvtph_ps( HV );
XM_STREAM_PS( reinterpret_cast<float*>(pFloat), FV );
pFloat += OutputStride*4;
pFloat += OutputStride*4;
i += 4;
}
}
@ -132,7 +132,7 @@ inline float* XMConvertHalfToFloatStream
__m128 FV = _mm_cvtph_ps( HV );
_mm_storeu_ps( reinterpret_cast<float*>(pFloat), FV );
pFloat += OutputStride*4;
pFloat += OutputStride*4;
i += 4;
}
}
@ -148,13 +148,13 @@ inline float* XMConvertHalfToFloatStream
__m128 FV = _mm_cvtph_ps( HV );
_mm_store_ss( reinterpret_cast<float*>(pFloat), FV );
pFloat += OutputStride;
pFloat += OutputStride;
*reinterpret_cast<int*>(pFloat) = _mm_extract_ps( FV, 1 );
pFloat += OutputStride;
pFloat += OutputStride;
*reinterpret_cast<int*>(pFloat) = _mm_extract_ps( FV, 2 );
pFloat += OutputStride;
pFloat += OutputStride;
*reinterpret_cast<int*>(pFloat) = _mm_extract_ps( FV, 3 );
pFloat += OutputStride;
pFloat += OutputStride;
i += 4;
}
}
@ -183,7 +183,7 @@ inline float* XMConvertHalfToFloatStream
__m128 FV = _mm_cvtph_ps( HV );
XM_STREAM_PS( reinterpret_cast<float*>(pFloat ), FV );
pFloat += OutputStride*4;
pFloat += OutputStride*4;
i += 4;
}
}
@ -209,7 +209,7 @@ inline float* XMConvertHalfToFloatStream
__m128 FV = _mm_cvtph_ps( HV );
_mm_storeu_ps( reinterpret_cast<float*>(pFloat ), FV );
pFloat += OutputStride*4;
pFloat += OutputStride*4;
i += 4;
}
}
@ -252,7 +252,7 @@ inline float* XMConvertHalfToFloatStream
{
*reinterpret_cast<float*>(pFloat) = XMConvertHalfToFloat(reinterpret_cast<const HALF*>(pHalf)[0]);
pHalf += InputStride;
pFloat += OutputStride;
pFloat += OutputStride;
}
XM_SFENCE();
@ -377,7 +377,7 @@ inline float* XMConvertHalfToFloatStream
{
*reinterpret_cast<float*>(pFloat) = XMConvertHalfToFloat(reinterpret_cast<const HALF*>(pHalf)[0]);
pHalf += InputStride;
pFloat += OutputStride;
pFloat += OutputStride;
}
return pOutputStream;
@ -437,7 +437,7 @@ inline HALF XMConvertFloatToHalf
IValue += 0xC8000000U;
}
Result = ((IValue + 0x0FFFU + ((IValue >> 13U) & 1U)) >> 13U)&0x7FFFU;
Result = ((IValue + 0x0FFFU + ((IValue >> 13U) & 1U)) >> 13U)&0x7FFFU;
}
return static_cast<HALF>(Result|Sign);
#endif // !_XM_F16C_INTRINSICS_
@ -447,10 +447,10 @@ inline HALF XMConvertFloatToHalf
_Use_decl_annotations_
inline HALF* XMConvertFloatToHalfStream
(
HALF* pOutputStream,
size_t OutputStride,
const float* pInputStream,
size_t InputStride,
HALF* pOutputStream,
size_t OutputStride,
const float* pInputStream,
size_t InputStride,
size_t FloatCount
)
{
@ -619,7 +619,7 @@ inline HALF* XMConvertFloatToHalfStream
for (; i < FloatCount; ++i)
{
*reinterpret_cast<HALF*>(pHalf) = XMConvertFloatToHalf(reinterpret_cast<const float*>(pFloat)[0]);
pFloat += InputStride;
pFloat += InputStride;
pHalf += OutputStride;
}
@ -732,7 +732,7 @@ inline HALF* XMConvertFloatToHalfStream
for (; i < FloatCount; ++i)
{
*reinterpret_cast<HALF*>(pHalf) = XMConvertFloatToHalf(reinterpret_cast<const float*>(pFloat)[0]);
pFloat += InputStride;
pFloat += InputStride;
pHalf += OutputStride;
}
@ -744,7 +744,7 @@ inline HALF* XMConvertFloatToHalfStream
for (size_t i = 0; i < FloatCount; i++)
{
*reinterpret_cast<HALF*>(pHalf) = XMConvertFloatToHalf(reinterpret_cast<const float*>(pFloat)[0]);
pFloat += InputStride;
pFloat += InputStride;
pHalf += OutputStride;
}
return pOutputStream;
@ -1227,20 +1227,20 @@ inline XMVECTOR XM_CALLCONV XMLoadFloat3PK
{
// Normalize the value in the resulting float
Exponent = 1;
do
{
Exponent--;
Mantissa <<= 1;
} while ((Mantissa & 0x40) == 0);
Mantissa &= 0x3F;
}
else // The value is zero
{
Exponent = static_cast<uint32_t>(-112);
}
Result[0] = ((Exponent + 112) << 23) | (Mantissa << 17);
}
@ -1261,20 +1261,20 @@ inline XMVECTOR XM_CALLCONV XMLoadFloat3PK
{
// Normalize the value in the resulting float
Exponent = 1;
do
{
Exponent--;
Mantissa <<= 1;
} while ((Mantissa & 0x40) == 0);
Mantissa &= 0x3F;
}
else // The value is zero
{
Exponent = static_cast<uint32_t>(-112);
}
Result[1] = ((Exponent + 112) << 23) | (Mantissa << 17);
}
@ -1295,13 +1295,13 @@ inline XMVECTOR XM_CALLCONV XMLoadFloat3PK
{
// Normalize the value in the resulting float
Exponent = 1;
do
{
Exponent--;
Mantissa <<= 1;
} while ((Mantissa & 0x20) == 0);
Mantissa &= 0x1F;
}
else // The value is zero
@ -2121,7 +2121,7 @@ inline XMVECTOR XM_CALLCONV XMLoadU555
_Use_decl_annotations_
inline void XM_CALLCONV XMStoreColor
(
XMCOLOR* pDestination,
XMCOLOR* pDestination,
FXMVECTOR V
)
{
@ -2159,7 +2159,7 @@ inline void XM_CALLCONV XMStoreColor
vResult = _mm_mul_ps(vResult,g_UByteMax);
// Shuffle RGBA to ARGB
vResult = XM_PERMUTE_PS(vResult,_MM_SHUFFLE(3,0,1,2));
// Convert to int
// Convert to int
__m128i vInt = _mm_cvtps_epi32(vResult);
// Mash to shorts
vInt = _mm_packs_epi32(vInt,vInt);
@ -2174,7 +2174,7 @@ inline void XM_CALLCONV XMStoreColor
_Use_decl_annotations_
inline void XM_CALLCONV XMStoreHalf2
(
XMHALF2* pDestination,
XMHALF2* pDestination,
FXMVECTOR V
)
{
@ -2192,7 +2192,7 @@ inline void XM_CALLCONV XMStoreHalf2
_Use_decl_annotations_
inline void XM_CALLCONV XMStoreShortN2
(
XMSHORTN2* pDestination,
XMSHORTN2* pDestination,
FXMVECTOR V
)
{
@ -2230,7 +2230,7 @@ inline void XM_CALLCONV XMStoreShortN2
_Use_decl_annotations_
inline void XM_CALLCONV XMStoreShort2
(
XMSHORT2* pDestination,
XMSHORT2* pDestination,
FXMVECTOR V
)
{
@ -2268,7 +2268,7 @@ inline void XM_CALLCONV XMStoreShort2
_Use_decl_annotations_
inline void XM_CALLCONV XMStoreUShortN2
(
XMUSHORTN2* pDestination,
XMUSHORTN2* pDestination,
FXMVECTOR V
)
{
@ -2312,7 +2312,7 @@ inline void XM_CALLCONV XMStoreUShortN2
_Use_decl_annotations_
inline void XM_CALLCONV XMStoreUShort2
(
XMUSHORT2* pDestination,
XMUSHORT2* pDestination,
FXMVECTOR V
)
{
@ -2351,7 +2351,7 @@ inline void XM_CALLCONV XMStoreUShort2
_Use_decl_annotations_
inline void XM_CALLCONV XMStoreByteN2
(
XMBYTEN2* pDestination,
XMBYTEN2* pDestination,
FXMVECTOR V
)
{
@ -2395,7 +2395,7 @@ inline void XM_CALLCONV XMStoreByteN2
_Use_decl_annotations_
inline void XM_CALLCONV XMStoreByte2
(
XMBYTE2* pDestination,
XMBYTE2* pDestination,
FXMVECTOR V
)
{
@ -2435,7 +2435,7 @@ inline void XM_CALLCONV XMStoreByte2
_Use_decl_annotations_
inline void XM_CALLCONV XMStoreUByteN2
(
XMUBYTEN2* pDestination,
XMUBYTEN2* pDestination,
FXMVECTOR V
)
{
@ -2481,7 +2481,7 @@ inline void XM_CALLCONV XMStoreUByteN2
_Use_decl_annotations_
inline void XM_CALLCONV XMStoreUByte2
(
XMUBYTE2* pDestination,
XMUBYTE2* pDestination,
FXMVECTOR V
)
{
@ -2629,7 +2629,7 @@ inline void XM_CALLCONV XMStoreFloat3PK
// Rebias the exponent to represent the value as a normalized float11
I += 0xC8000000U;
}
Result[j] = ((I + 0xFFFFU + ((I >> 17U) & 1U)) >> 17U)&0x7ffU;
}
}
@ -2676,7 +2676,7 @@ inline void XM_CALLCONV XMStoreFloat3PK
// Rebias the exponent to represent the value as a normalized float10
I += 0xC8000000U;
}
Result[2] = ((I + 0x1FFFFU + ((I >> 18U) & 1U)) >> 18U)&0x3ffU;
}
@ -2730,7 +2730,7 @@ inline void XM_CALLCONV XMStoreFloat3SE
_Use_decl_annotations_
inline void XM_CALLCONV XMStoreHalf4
(
XMHALF4* pDestination,
XMHALF4* pDestination,
FXMVECTOR V
)
{
@ -2753,7 +2753,7 @@ inline void XM_CALLCONV XMStoreHalf4
_Use_decl_annotations_
inline void XM_CALLCONV XMStoreShortN4
(
XMSHORTN4* pDestination,
XMSHORTN4* pDestination,
FXMVECTOR V
)
{
@ -2793,7 +2793,7 @@ inline void XM_CALLCONV XMStoreShortN4
_Use_decl_annotations_
inline void XM_CALLCONV XMStoreShort4
(
XMSHORT4* pDestination,
XMSHORT4* pDestination,
FXMVECTOR V
)
{
@ -2833,7 +2833,7 @@ inline void XM_CALLCONV XMStoreShort4
_Use_decl_annotations_
inline void XM_CALLCONV XMStoreUShortN4
(
XMUSHORTN4* pDestination,
XMUSHORTN4* pDestination,
FXMVECTOR V
)
{
@ -2881,7 +2881,7 @@ inline void XM_CALLCONV XMStoreUShortN4
_Use_decl_annotations_
inline void XM_CALLCONV XMStoreUShort4
(
XMUSHORT4* pDestination,
XMUSHORT4* pDestination,
FXMVECTOR V
)
{
@ -2924,7 +2924,7 @@ inline void XM_CALLCONV XMStoreUShort4
_Use_decl_annotations_
inline void XM_CALLCONV XMStoreXDecN4
(
XMXDECN4* pDestination,
XMXDECN4* pDestination,
FXMVECTOR V
)
{
@ -2997,7 +2997,7 @@ inline void XM_CALLCONV XMStoreXDecN4
_Use_decl_annotations_
inline void XM_CALLCONV XMStoreXDec4
(
XMXDEC4* pDestination,
XMXDEC4* pDestination,
FXMVECTOR V
)
{
@ -3067,7 +3067,7 @@ inline void XM_CALLCONV XMStoreXDec4
_Use_decl_annotations_
inline void XM_CALLCONV XMStoreUDecN4
(
XMUDECN4* pDestination,
XMUDECN4* pDestination,
FXMVECTOR V
)
{
@ -3135,7 +3135,7 @@ inline void XM_CALLCONV XMStoreUDecN4
_Use_decl_annotations_
inline void XM_CALLCONV XMStoreUDecN4_XR
(
XMUDECN4* pDestination,
XMUDECN4* pDestination,
FXMVECTOR V
)
{
@ -3209,7 +3209,7 @@ inline void XM_CALLCONV XMStoreUDecN4_XR
_Use_decl_annotations_
inline void XM_CALLCONV XMStoreUDec4
(
XMUDEC4* pDestination,
XMUDEC4* pDestination,
FXMVECTOR V
)
{
@ -3280,7 +3280,7 @@ inline void XM_CALLCONV XMStoreUDec4
_Use_decl_annotations_
inline void XM_CALLCONV XMStoreDecN4
(
XMDECN4* pDestination,
XMDECN4* pDestination,
FXMVECTOR V
)
{
@ -3341,7 +3341,7 @@ inline void XM_CALLCONV XMStoreDecN4
_Use_decl_annotations_
inline void XM_CALLCONV XMStoreDec4
(
XMDEC4* pDestination,
XMDEC4* pDestination,
FXMVECTOR V
)
{
@ -3404,7 +3404,7 @@ inline void XM_CALLCONV XMStoreDec4
_Use_decl_annotations_
inline void XM_CALLCONV XMStoreUByteN4
(
XMUBYTEN4* pDestination,
XMUBYTEN4* pDestination,
FXMVECTOR V
)
{
@ -3449,7 +3449,7 @@ inline void XM_CALLCONV XMStoreUByteN4
vResulti = _mm_or_si128(vResulti,vResulti2);
// Move Z to the x position
vResulti2 = _mm_shuffle_epi32(vResulti,_MM_SHUFFLE(1,1,1,1));
// Perform a single bit left shift to fix y|w
// Perform a single bit left shift to fix y|w
vResulti2 = _mm_add_epi32(vResulti2,vResulti2);
// i = x|y|z|w
vResulti = _mm_or_si128(vResulti,vResulti2);
@ -3461,7 +3461,7 @@ inline void XM_CALLCONV XMStoreUByteN4
_Use_decl_annotations_
inline void XM_CALLCONV XMStoreUByte4
(
XMUBYTE4* pDestination,
XMUBYTE4* pDestination,
FXMVECTOR V
)
{
@ -3504,7 +3504,7 @@ inline void XM_CALLCONV XMStoreUByte4
vResulti = _mm_or_si128(vResulti,vResulti2);
// Move Z to the x position
vResulti2 = _mm_shuffle_epi32(vResulti,_MM_SHUFFLE(1,1,1,1));
// Perform a single bit left shift to fix y|w
// Perform a single bit left shift to fix y|w
vResulti2 = _mm_add_epi32(vResulti2,vResulti2);
// i = x|y|z|w
vResulti = _mm_or_si128(vResulti,vResulti2);
@ -3516,7 +3516,7 @@ inline void XM_CALLCONV XMStoreUByte4
_Use_decl_annotations_
inline void XM_CALLCONV XMStoreByteN4
(
XMBYTEN4* pDestination,
XMBYTEN4* pDestination,
FXMVECTOR V
)
{
@ -3571,7 +3571,7 @@ inline void XM_CALLCONV XMStoreByteN4
_Use_decl_annotations_
inline void XM_CALLCONV XMStoreByte4
(
XMBYTE4* pDestination,
XMBYTE4* pDestination,
FXMVECTOR V
)
{