Bart/bullet3
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Minor update SSE version of SCE Vectormath library

Browse Source 
Changes:
Update copyright year to 2010
Updated operator- for Vector3 (use NEG_MASK)
Use  newtonrapson_rsqrt4 for Quat::normalize (better precision)
Add Vector::loadXYZW and Quat::loadXYZW, similar to scalar version, using _mm_lddqu_si128
Replace inline by __forceinline
Add get128Ref and set128() methods
This commit is contained in:
erwin.coumans
2010-05-07 02:25:20 +00:00
parent c35e72bd9f
commit f9445bdfde
7 changed files with 3100 additions and 2998 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
Extras/vectormathlibrary/include/vectormath/SSE/cpp/boolInVec.h
View File

@@ -1,5 +1,5 @@
/* /*
Copyright (C) 2006, 2007 Sony Computer Entertainment Inc. Copyright (C) 2006, 2010 Sony Computer Entertainment Inc.
All rights reserved. All rights reserved.
Redistribution and use in source and binary forms, Redistribution and use in source and binary forms,

2
Extras/vectormathlibrary/include/vectormath/SSE/cpp/floatInVec.h
View File

@@ -1,5 +1,5 @@
/* /*
Copyright (C) 2006, 2007 Sony Computer Entertainment Inc. Copyright (C) 2006, 2010 Sony Computer Entertainment Inc.
All rights reserved. All rights reserved.
Redistribution and use in source and binary forms, Redistribution and use in source and binary forms,

394
Extras/vectormathlibrary/include/vectormath/SSE/cpp/mat_aos.h
View File

File diff suppressed because it is too large Load Diff

193
Extras/vectormathlibrary/include/vectormath/SSE/cpp/quat_aos.h
View File

@@ -1,5 +1,5 @@
/* /*
Copyright (C) 2006, 2007 Sony Computer Entertainment Inc. Copyright (C) 2006, 2010 Sony Computer Entertainment Inc.
All rights reserved. All rights reserved.
Redistribution and use in source and binary forms, Redistribution and use in source and binary forms,
@@ -42,80 +42,96 @@
namespace Vectormath { namespace Vectormath {
namespace Aos { namespace Aos {
inline Quat::Quat( float _x, float _y, float _z, float _w ) __forceinline void Quat::set128(vec_float4 vec)
{ {
mVec128 = _mm_setr_ps(_x, _y, _z, _w); mVec128 = vec;
} }
inline Quat::Quat( const floatInVec &_x, const floatInVec &_y, const floatInVec &_z, const floatInVec &_w ) __forceinline Quat::Quat( const floatInVec &_x, const floatInVec &_y, const floatInVec &_z, const floatInVec &_w )
{ {
mVec128 = _mm_unpacklo_ps( mVec128 = _mm_unpacklo_ps(
_mm_unpacklo_ps( _x.get128(), _z.get128() ), _mm_unpacklo_ps( _x.get128(), _z.get128() ),
_mm_unpacklo_ps( _y.get128(), _w.get128() ) ); _mm_unpacklo_ps( _y.get128(), _w.get128() ) );
} }
inline Quat::Quat( const Vector3 &xyz, float _w ) __forceinline Quat::Quat( const Vector3 &xyz, float _w )
{ {
mVec128 = xyz.get128(); mVec128 = xyz.get128();
_vmathVfSetElement(mVec128, _w, 3); _vmathVfSetElement(mVec128, _w, 3);
} }
inline Quat::Quat( const Vector3 &xyz, const floatInVec &_w )
__forceinline Quat::Quat(const Quat& quat)
{
mVec128 = quat.get128();
}
__forceinline Quat::Quat( float _x, float _y, float _z, float _w )
{
mVec128 = _mm_setr_ps(_x, _y, _z, _w);
}
__forceinline Quat::Quat( const Vector3 &xyz, const floatInVec &_w )
{ {
mVec128 = xyz.get128(); mVec128 = xyz.get128();
mVec128 = _vmathVfInsert(mVec128, _w.get128(), 3); mVec128 = _vmathVfInsert(mVec128, _w.get128(), 3);
} }
inline Quat::Quat( const Vector4 &vec ) __forceinline Quat::Quat( const Vector4 &vec )
{ {
mVec128 = vec.get128(); mVec128 = vec.get128();
} }
inline Quat::Quat( float scalar ) __forceinline Quat::Quat( float scalar )
{ {
mVec128 = floatInVec(scalar).get128(); mVec128 = floatInVec(scalar).get128();
} }
inline Quat::Quat( const floatInVec &scalar ) __forceinline Quat::Quat( const floatInVec &scalar )
{ {
mVec128 = scalar.get128(); mVec128 = scalar.get128();
} }
inline Quat::Quat( __m128 vf4 ) __forceinline Quat::Quat( __m128 vf4 )
{ {
mVec128 = vf4; mVec128 = vf4;
} }
inline const Quat Quat::identity( ) __forceinline const Quat Quat::identity( )
{ {
return Quat( _VECTORMATH_UNIT_0001 ); return Quat( _VECTORMATH_UNIT_0001 );
} }
inline const Quat lerp( float t, const Quat &quat0, const Quat &quat1 ) __forceinline const Quat lerp( float t, const Quat &quat0, const Quat &quat1 )
{ {
return lerp( floatInVec(t), quat0, quat1 ); return lerp( floatInVec(t), quat0, quat1 );
} }
inline const Quat lerp( const floatInVec &t, const Quat &quat0, const Quat &quat1 ) __forceinline const Quat lerp( const floatInVec &t, const Quat &quat0, const Quat &quat1 )
{ {
return ( quat0 + ( ( quat1 - quat0 ) * t ) ); return ( quat0 + ( ( quat1 - quat0 ) * t ) );
} }
inline const Quat slerp( float t, const Quat &unitQuat0, const Quat &unitQuat1 ) __forceinline const Quat slerp( float t, const Quat &unitQuat0, const Quat &unitQuat1 )
{ {
return slerp( floatInVec(t), unitQuat0, unitQuat1 ); return slerp( floatInVec(t), unitQuat0, unitQuat1 );
} }
inline const Quat slerp( const floatInVec &t, const Quat &unitQuat0, const Quat &unitQuat1 ) __forceinline const Quat slerp( const floatInVec &t, const Quat &unitQuat0, const Quat &unitQuat1 )
{ {
Quat start; Quat start;
vec_float4 scales, scale0, scale1, cosAngle, angle, tttt, oneMinusT, angles, sines; vec_float4 scales, scale0, scale1, cosAngle, angle, tttt, oneMinusT, angles, sines;
vec_uint4 selectMask; __m128 selectMask;
cosAngle = _vmathVfDot4( unitQuat0.get128(), unitQuat1.get128() ); cosAngle = _vmathVfDot4( unitQuat0.get128(), unitQuat1.get128() );
selectMask = (vec_uint4)vec_cmpgt( _mm_setzero_ps(), cosAngle ); selectMask = (__m128)vec_cmpgt( _mm_setzero_ps(), cosAngle );
cosAngle = vec_sel( cosAngle, negatef4( cosAngle ), selectMask ); cosAngle = vec_sel( cosAngle, negatef4( cosAngle ), selectMask );
start = Quat( vec_sel( unitQuat0.get128(), negatef4( unitQuat0.get128() ), selectMask ) ); start = Quat( vec_sel( unitQuat0.get128(), negatef4( unitQuat0.get128() ), selectMask ) );
selectMask = (vec_uint4)vec_cmpgt( _mm_set1_ps(_VECTORMATH_SLERP_TOL), cosAngle ); selectMask = (__m128)vec_cmpgt( _mm_set1_ps(_VECTORMATH_SLERP_TOL), cosAngle );
angle = acosf4( cosAngle ); angle = acosf4( cosAngle );
tttt = t.get128(); tttt = t.get128();
oneMinusT = vec_sub( _mm_set1_ps(1.0f), tttt ); oneMinusT = vec_sub( _mm_set1_ps(1.0f), tttt );
@@ -129,236 +145,239 @@ inline const Quat slerp( const floatInVec &t, const Quat &unitQuat0, const Quat
return Quat( vec_madd( start.get128(), scale0, vec_mul( unitQuat1.get128(), scale1 ) ) ); return Quat( vec_madd( start.get128(), scale0, vec_mul( unitQuat1.get128(), scale1 ) ) );
} }
inline const Quat squad( float t, const Quat &unitQuat0, const Quat &unitQuat1, const Quat &unitQuat2, const Quat &unitQuat3 ) __forceinline const Quat squad( float t, const Quat &unitQuat0, const Quat &unitQuat1, const Quat &unitQuat2, const Quat &unitQuat3 )
{ {
return squad( floatInVec(t), unitQuat0, unitQuat1, unitQuat2, unitQuat3 ); return squad( floatInVec(t), unitQuat0, unitQuat1, unitQuat2, unitQuat3 );
} }
inline const Quat squad( const floatInVec &t, const Quat &unitQuat0, const Quat &unitQuat1, const Quat &unitQuat2, const Quat &unitQuat3 ) __forceinline const Quat squad( const floatInVec &t, const Quat &unitQuat0, const Quat &unitQuat1, const Quat &unitQuat2, const Quat &unitQuat3 )
{ {
return slerp( ( ( floatInVec(2.0f) * t ) * ( floatInVec(1.0f) - t ) ), slerp( t, unitQuat0, unitQuat3 ), slerp( t, unitQuat1, unitQuat2 ) ); return slerp( ( ( floatInVec(2.0f) * t ) * ( floatInVec(1.0f) - t ) ), slerp( t, unitQuat0, unitQuat3 ), slerp( t, unitQuat1, unitQuat2 ) );
} }
inline __m128 Quat::get128( ) const __forceinline __m128 Quat::get128( ) const
{ {
return mVec128; return mVec128;
} }
inline Quat & Quat::operator =( const Quat &quat ) __forceinline Quat & Quat::operator =( const Quat &quat )
{ {
mVec128 = quat.mVec128; mVec128 = quat.mVec128;
return *this; return *this;
} }
inline Quat & Quat::setXYZ( const Vector3 &vec ) __forceinline Quat & Quat::setXYZ( const Vector3 &vec )
{ {
__declspec(align(16)) unsigned int sw[4] = {0, 0, 0, 0xffffffff}; __declspec(align(16)) unsigned int sw[4] = {0, 0, 0, 0xffffffff};
mVec128 = vec_sel( vec.get128(), mVec128, sw ); mVec128 = vec_sel( vec.get128(), mVec128, sw );
return *this; return *this;
} }
inline const Vector3 Quat::getXYZ( ) const __forceinline const Vector3 Quat::getXYZ( ) const
{ {
return Vector3( mVec128 ); return Vector3( mVec128 );
} }
inline Quat & Quat::setX( float _x ) __forceinline Quat & Quat::setX( float _x )
{ {
_vmathVfSetElement(mVec128, _x, 0); _vmathVfSetElement(mVec128, _x, 0);
return *this; return *this;
} }
inline Quat & Quat::setX( const floatInVec &_x ) __forceinline Quat & Quat::setX( const floatInVec &_x )
{ {
mVec128 = _vmathVfInsert(mVec128, _x.get128(), 0); mVec128 = _vmathVfInsert(mVec128, _x.get128(), 0);
return *this; return *this;
} }
inline const floatInVec Quat::getX( ) const __forceinline const floatInVec Quat::getX( ) const
{ {
return floatInVec( mVec128, 0 ); return floatInVec( mVec128, 0 );
} }
inline Quat & Quat::setY( float _y ) __forceinline Quat & Quat::setY( float _y )
{ {
_vmathVfSetElement(mVec128, _y, 1); _vmathVfSetElement(mVec128, _y, 1);
return *this; return *this;
} }
inline Quat & Quat::setY( const floatInVec &_y ) __forceinline Quat & Quat::setY( const floatInVec &_y )
{ {
mVec128 = _vmathVfInsert(mVec128, _y.get128(), 1); mVec128 = _vmathVfInsert(mVec128, _y.get128(), 1);
return *this; return *this;
} }
inline const floatInVec Quat::getY( ) const __forceinline const floatInVec Quat::getY( ) const
{ {
return floatInVec( mVec128, 1 ); return floatInVec( mVec128, 1 );
} }
inline Quat & Quat::setZ( float _z ) __forceinline Quat & Quat::setZ( float _z )
{ {
_vmathVfSetElement(mVec128, _z, 2); _vmathVfSetElement(mVec128, _z, 2);
return *this; return *this;
} }
inline Quat & Quat::setZ( const floatInVec &_z ) __forceinline Quat & Quat::setZ( const floatInVec &_z )
{ {
mVec128 = _vmathVfInsert(mVec128, _z.get128(), 2); mVec128 = _vmathVfInsert(mVec128, _z.get128(), 2);
return *this; return *this;
} }
inline const floatInVec Quat::getZ( ) const __forceinline const floatInVec Quat::getZ( ) const
{ {
return floatInVec( mVec128, 2 ); return floatInVec( mVec128, 2 );
} }
inline Quat & Quat::setW( float _w ) __forceinline Quat & Quat::setW( float _w )
{ {
_vmathVfSetElement(mVec128, _w, 3); _vmathVfSetElement(mVec128, _w, 3);
return *this; return *this;
} }
inline Quat & Quat::setW( const floatInVec &_w ) __forceinline Quat & Quat::setW( const floatInVec &_w )
{ {
mVec128 = _vmathVfInsert(mVec128, _w.get128(), 3); mVec128 = _vmathVfInsert(mVec128, _w.get128(), 3);
return *this; return *this;
} }
inline const floatInVec Quat::getW( ) const __forceinline const floatInVec Quat::getW( ) const
{ {
return floatInVec( mVec128, 3 ); return floatInVec( mVec128, 3 );
} }
inline Quat & Quat::setElem( int idx, float value ) __forceinline Quat & Quat::setElem( int idx, float value )
{ {
_vmathVfSetElement(mVec128, value, idx); _vmathVfSetElement(mVec128, value, idx);
return *this; return *this;
} }
inline Quat & Quat::setElem( int idx, const floatInVec &value ) __forceinline Quat & Quat::setElem( int idx, const floatInVec &value )
{ {
mVec128 = _vmathVfInsert(mVec128, value.get128(), idx); mVec128 = _vmathVfInsert(mVec128, value.get128(), idx);
return *this; return *this;
} }
inline const floatInVec Quat::getElem( int idx ) const __forceinline const floatInVec Quat::getElem( int idx ) const
{ {
return floatInVec( mVec128, idx ); return floatInVec( mVec128, idx );
} }
inline VecIdx Quat::operator []( int idx ) __forceinline VecIdx Quat::operator []( int idx )
{ {
return VecIdx( mVec128, idx ); return VecIdx( mVec128, idx );
} }
inline const floatInVec Quat::operator []( int idx ) const __forceinline const floatInVec Quat::operator []( int idx ) const
{ {
return floatInVec( mVec128, idx ); return floatInVec( mVec128, idx );
} }
inline const Quat Quat::operator +( const Quat &quat ) const __forceinline const Quat Quat::operator +( const Quat &quat ) const
{ {
return Quat( _mm_add_ps( mVec128, quat.mVec128 ) ); return Quat( _mm_add_ps( mVec128, quat.mVec128 ) );
} }
inline const Quat Quat::operator -( const Quat &quat ) const
__forceinline const Quat Quat::operator -( const Quat &quat ) const
{ {
return Quat( _mm_sub_ps( mVec128, quat.mVec128 ) ); return Quat( _mm_sub_ps( mVec128, quat.mVec128 ) );
} }
inline const Quat Quat::operator *( float scalar ) const __forceinline const Quat Quat::operator *( float scalar ) const
{ {
return *this * floatInVec(scalar); return *this * floatInVec(scalar);
} }
inline const Quat Quat::operator *( const floatInVec &scalar ) const __forceinline const Quat Quat::operator *( const floatInVec &scalar ) const
{ {
return Quat( _mm_mul_ps( mVec128, scalar.get128() ) ); return Quat( _mm_mul_ps( mVec128, scalar.get128() ) );
} }
inline Quat & Quat::operator +=( const Quat &quat ) __forceinline Quat & Quat::operator +=( const Quat &quat )
{ {
*this = *this + quat; *this = *this + quat;
return *this; return *this;
} }
inline Quat & Quat::operator -=( const Quat &quat ) __forceinline Quat & Quat::operator -=( const Quat &quat )
{ {
*this = *this - quat; *this = *this - quat;
return *this; return *this;
} }
inline Quat & Quat::operator *=( float scalar ) __forceinline Quat & Quat::operator *=( float scalar )
{ {
*this = *this * scalar; *this = *this * scalar;
return *this; return *this;
} }
inline Quat & Quat::operator *=( const floatInVec &scalar ) __forceinline Quat & Quat::operator *=( const floatInVec &scalar )
{ {
*this = *this * scalar; *this = *this * scalar;
return *this; return *this;
} }
inline const Quat Quat::operator /( float scalar ) const __forceinline const Quat Quat::operator /( float scalar ) const
{ {
return *this / floatInVec(scalar); return *this / floatInVec(scalar);
} }
inline const Quat Quat::operator /( const floatInVec &scalar ) const __forceinline const Quat Quat::operator /( const floatInVec &scalar ) const
{ {
return Quat( _mm_div_ps( mVec128, scalar.get128() ) ); return Quat( _mm_div_ps( mVec128, scalar.get128() ) );
} }
inline Quat & Quat::operator /=( float scalar ) __forceinline Quat & Quat::operator /=( float scalar )
{ {
*this = *this / scalar; *this = *this / scalar;
return *this; return *this;
} }
inline Quat & Quat::operator /=( const floatInVec &scalar ) __forceinline Quat & Quat::operator /=( const floatInVec &scalar )
{ {
*this = *this / scalar; *this = *this / scalar;
return *this; return *this;
} }
inline const Quat Quat::operator -( ) const __forceinline const Quat Quat::operator -( ) const
{ {
return Quat(_mm_sub_ps( _mm_setzero_ps(), mVec128 ) ); return Quat(_mm_sub_ps( _mm_setzero_ps(), mVec128 ) );
} }
inline const Quat operator *( float scalar, const Quat &quat ) __forceinline const Quat operator *( float scalar, const Quat &quat )
{ {
return floatInVec(scalar) * quat; return floatInVec(scalar) * quat;
} }
inline const Quat operator *( const floatInVec &scalar, const Quat &quat ) __forceinline const Quat operator *( const floatInVec &scalar, const Quat &quat )
{ {
return quat * scalar; return quat * scalar;
} }
inline const floatInVec dot( const Quat &quat0, const Quat &quat1 ) __forceinline const floatInVec dot( const Quat &quat0, const Quat &quat1 )
{ {
return floatInVec( _vmathVfDot4( quat0.get128(), quat1.get128() ), 0 ); return floatInVec( _vmathVfDot4( quat0.get128(), quat1.get128() ), 0 );
} }
inline const floatInVec norm( const Quat &quat ) __forceinline const floatInVec norm( const Quat &quat )
{ {
return floatInVec( _vmathVfDot4( quat.get128(), quat.get128() ), 0 ); return floatInVec( _vmathVfDot4( quat.get128(), quat.get128() ), 0 );
} }
inline const floatInVec length( const Quat &quat ) __forceinline const floatInVec length( const Quat &quat )
{ {
return floatInVec( _mm_sqrt_ps(_vmathVfDot4( quat.get128(), quat.get128() )), 0 ); return floatInVec( _mm_sqrt_ps(_vmathVfDot4( quat.get128(), quat.get128() )), 0 );
} }
inline const Quat normalize( const Quat &quat ) __forceinline const Quat normalize( const Quat &quat )
{ {
return Quat( _mm_mul_ps( quat.get128(), _mm_rsqrt_ps( _vmathVfDot4( quat.get128(), quat.get128() ) ) ) ); vec_float4 dot =_vmathVfDot4( quat.get128(), quat.get128());
return Quat( _mm_mul_ps( quat.get128(), newtonrapson_rsqrt4( dot ) ) );
} }
inline const Quat Quat::rotation( const Vector3 &unitVec0, const Vector3 &unitVec1 )
__forceinline const Quat Quat::rotation( const Vector3 &unitVec0, const Vector3 &unitVec1 )
{ {
Vector3 crossVec; Vector3 crossVec;
__m128 cosAngle, cosAngleX2Plus2, recipCosHalfAngleX2, cosHalfAngleX2, res; __m128 cosAngle, cosAngleX2Plus2, recipCosHalfAngleX2, cosHalfAngleX2, res;
@@ -373,12 +392,12 @@ inline const Quat Quat::rotation( const Vector3 &unitVec0, const Vector3 &unitVe
return Quat( res ); return Quat( res );
} }
inline const Quat Quat::rotation( float radians, const Vector3 &unitVec ) __forceinline const Quat Quat::rotation( float radians, const Vector3 &unitVec )
{ {
return rotation( floatInVec(radians), unitVec ); return rotation( floatInVec(radians), unitVec );
} }
inline const Quat Quat::rotation( const floatInVec &radians, const Vector3 &unitVec ) __forceinline const Quat Quat::rotation( const floatInVec &radians, const Vector3 &unitVec )
{ {
__m128 s, c, angle, res; __m128 s, c, angle, res;
angle = vec_mul( radians.get128(), _mm_set1_ps(0.5f) ); angle = vec_mul( radians.get128(), _mm_set1_ps(0.5f) );
@@ -388,12 +407,12 @@ inline const Quat Quat::rotation( const floatInVec &radians, const Vector3 &unit
return Quat( res ); return Quat( res );
} }
inline const Quat Quat::rotationX( float radians ) __forceinline const Quat Quat::rotationX( float radians )
{ {
return rotationX( floatInVec(radians) ); return rotationX( floatInVec(radians) );
} }
inline const Quat Quat::rotationX( const floatInVec &radians ) __forceinline const Quat Quat::rotationX( const floatInVec &radians )
{ {
__m128 s, c, angle, res; __m128 s, c, angle, res;
angle = vec_mul( radians.get128(), _mm_set1_ps(0.5f) ); angle = vec_mul( radians.get128(), _mm_set1_ps(0.5f) );
@@ -405,12 +424,12 @@ inline const Quat Quat::rotationX( const floatInVec &radians )
return Quat( res ); return Quat( res );
} }
inline const Quat Quat::rotationY( float radians ) __forceinline const Quat Quat::rotationY( float radians )
{ {
return rotationY( floatInVec(radians) ); return rotationY( floatInVec(radians) );
} }
inline const Quat Quat::rotationY( const floatInVec &radians ) __forceinline const Quat Quat::rotationY( const floatInVec &radians )
{ {
__m128 s, c, angle, res; __m128 s, c, angle, res;
angle = vec_mul( radians.get128(), _mm_set1_ps(0.5f) ); angle = vec_mul( radians.get128(), _mm_set1_ps(0.5f) );
@@ -422,12 +441,12 @@ inline const Quat Quat::rotationY( const floatInVec &radians )
return Quat( res ); return Quat( res );
} }
inline const Quat Quat::rotationZ( float radians ) __forceinline const Quat Quat::rotationZ( float radians )
{ {
return rotationZ( floatInVec(radians) ); return rotationZ( floatInVec(radians) );
} }
inline const Quat Quat::rotationZ( const floatInVec &radians ) __forceinline const Quat Quat::rotationZ( const floatInVec &radians )
{ {
__m128 s, c, angle, res; __m128 s, c, angle, res;
angle = vec_mul( radians.get128(), _mm_set1_ps(0.5f) ); angle = vec_mul( radians.get128(), _mm_set1_ps(0.5f) );
@@ -439,7 +458,7 @@ inline const Quat Quat::rotationZ( const floatInVec &radians )
return Quat( res ); return Quat( res );
} }
inline const Quat Quat::operator *( const Quat &quat ) const __forceinline const Quat Quat::operator *( const Quat &quat ) const
{ {
__m128 ldata, rdata, qv, tmp0, tmp1, tmp2, tmp3; __m128 ldata, rdata, qv, tmp0, tmp1, tmp2, tmp3;
__m128 product, l_wxyz, r_wxyz, xy, qw; __m128 product, l_wxyz, r_wxyz, xy, qw;
@@ -463,13 +482,13 @@ inline const Quat Quat::operator *( const Quat &quat ) const
return Quat( vec_sel( qv, qw, sw ) ); return Quat( vec_sel( qv, qw, sw ) );
} }
inline Quat & Quat::operator *=( const Quat &quat ) __forceinline Quat & Quat::operator *=( const Quat &quat )
{ {
*this = *this * quat; *this = *this * quat;
return *this; return *this;
} }
inline const Vector3 rotate( const Quat &quat, const Vector3 &vec ) __forceinline const Vector3 rotate( const Quat &quat, const Vector3 &vec )
{ __m128 qdata, vdata, product, tmp0, tmp1, tmp2, tmp3, wwww, qv, qw, res; { __m128 qdata, vdata, product, tmp0, tmp1, tmp2, tmp3, wwww, qv, qw, res;
qdata = quat.get128(); qdata = quat.get128();
vdata = vec.get128(); vdata = vec.get128();
@@ -493,32 +512,48 @@ inline const Vector3 rotate( const Quat &quat, const Vector3 &vec )
return Vector3( res ); return Vector3( res );
} }
inline const Quat conj( const Quat &quat ) __forceinline const Quat conj( const Quat &quat )
{ {
__declspec(align(16)) unsigned int sw[4] = {0x80000000,0x80000000,0x80000000,0}; __declspec(align(16)) unsigned int sw[4] = {0x80000000,0x80000000,0x80000000,0};
return Quat( vec_xor( quat.get128(), _mm_load_ps((float *)sw) ) ); return Quat( vec_xor( quat.get128(), _mm_load_ps((float *)sw) ) );
} }
inline const Quat select( const Quat &quat0, const Quat &quat1, bool select1 ) __forceinline const Quat select( const Quat &quat0, const Quat &quat1, bool select1 )
{ {
return select( quat0, quat1, boolInVec(select1) ); return select( quat0, quat1, boolInVec(select1) );
} }
inline const Quat select( const Quat &quat0, const Quat &quat1, const boolInVec &select1 ) //__forceinline const Quat select( const Quat &quat0, const Quat &quat1, const boolInVec &select1 )
//{
// return Quat( vec_sel( quat0.get128(), quat1.get128(), select1.get128() ) );
//}
__forceinline void loadXYZW(Quat& quat, const float* fptr)
{ {
return Quat( vec_sel( quat0.get128(), quat1.get128(), select1.get128() ) ); #ifdef USE_SSE2_LDDQU
quat = Quat( SSEFloat(_mm_lddqu_si128((const __m128i*)((float*)(fptr)))).m128 );
#else
SSEFloat fl;
fl.f[0] = fptr[0];
fl.f[1] = fptr[1];
fl.f[2] = fptr[2];
fl.f[3] = fptr[3];
quat = Quat( fl.m128);
#endif
} }
#ifdef _VECTORMATH_DEBUG #ifdef _VECTORMATH_DEBUG
inline void print( const Quat &quat ) __forceinline void print( const Quat &quat )
{ {
union { __m128 v; float s[4]; } tmp; union { __m128 v; float s[4]; } tmp;
tmp.v = quat.get128(); tmp.v = quat.get128();
printf( "( %f %f %f %f )\n", tmp.s[0], tmp.s[1], tmp.s[2], tmp.s[3] ); printf( "( %f %f %f %f )\n", tmp.s[0], tmp.s[1], tmp.s[2], tmp.s[3] );
} }
inline void print( const Quat &quat, const char * name ) __forceinline void print( const Quat &quat, const char * name )
{ {
union { __m128 v; float s[4]; } tmp; union { __m128 v; float s[4]; } tmp;
tmp.v = quat.get128(); tmp.v = quat.get128();

490
Extras/vectormathlibrary/include/vectormath/SSE/cpp/vec_aos.h
View File

File diff suppressed because it is too large Load Diff

2
Extras/vectormathlibrary/include/vectormath/SSE/cpp/vecidx_aos.h
View File

@@ -1,5 +1,5 @@
/* /*
Copyright (C) 2006, 2007 Sony Computer Entertainment Inc. Copyright (C) 2006, 2010 Sony Computer Entertainment Inc.
All rights reserved. All rights reserved.
Redistribution and use in source and binary forms, Redistribution and use in source and binary forms,

995
Extras/vectormathlibrary/include/vectormath/SSE/cpp/vectormath_aos.h
View File

File diff suppressed because it is too large Load Diff