Added vectormath library, the open source version. Currently, PowerPC PPU, Cell SPU and a scalar version is available.
An SSE port of vectormath might become available too.
This commit is contained in:
ejcoumans
1833
Extras/vectormathlibrary/include/vectormath/spu/c/mat_aos.h
Normal file
1833
Extras/vectormathlibrary/include/vectormath/spu/c/mat_aos.h
Normal file
File diff suppressed because it is too large
Load Diff
1029
Extras/vectormathlibrary/include/vectormath/spu/c/mat_aos_v.h
Normal file
1029
Extras/vectormathlibrary/include/vectormath/spu/c/mat_aos_v.h
Normal file
File diff suppressed because it is too large
Load Diff
1493
Extras/vectormathlibrary/include/vectormath/spu/c/mat_soa.h
Normal file
1493
Extras/vectormathlibrary/include/vectormath/spu/c/mat_soa.h
Normal file
File diff suppressed because it is too large
Load Diff
1063
Extras/vectormathlibrary/include/vectormath/spu/c/mat_soa_v.h
Normal file
1063
Extras/vectormathlibrary/include/vectormath/spu/c/mat_soa_v.h
Normal file
File diff suppressed because it is too large
Load Diff
371
Extras/vectormathlibrary/include/vectormath/spu/c/quat_aos.h
Normal file
371
Extras/vectormathlibrary/include/vectormath/spu/c/quat_aos.h
Normal file
@@ -0,0 +1,371 @@
|
||||
/*
|
||||
Copyright (C) 2006, 2007 Sony Computer Entertainment Inc.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms,
|
||||
with or without modification, are permitted provided that the
|
||||
following conditions are met:
|
||||
* Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
* Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in the
|
||||
documentation and/or other materials provided with the distribution.
|
||||
* Neither the name of the Sony Computer Entertainment Inc nor the names
|
||||
of its contributors may be used to endorse or promote products derived
|
||||
from this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
||||
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#ifndef _VECTORMATH_QUAT_AOS_C_H
|
||||
#define _VECTORMATH_QUAT_AOS_C_H
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif /* __cplusplus */
|
||||
|
||||
/*-----------------------------------------------------------------------------
|
||||
* Definitions
|
||||
*/
|
||||
#ifndef _VECTORMATH_INTERNAL_FUNCTIONS
|
||||
#define _VECTORMATH_INTERNAL_FUNCTIONS
|
||||
|
||||
#endif
|
||||
|
||||
static inline void vmathQCopy( VmathQuat *result, const VmathQuat *quat )
|
||||
{
|
||||
result->vec128 = quat->vec128;
|
||||
}
|
||||
|
||||
static inline void vmathQMakeFromElems( VmathQuat *result, float _x, float _y, float _z, float _w )
|
||||
{
|
||||
result->vec128 = (vec_float4){ _x, _y, _z, _w };
|
||||
}
|
||||
|
||||
static inline void vmathQMakeFromV3Scalar( VmathQuat *result, const VmathVector3 *xyz, float _w )
|
||||
{
|
||||
result->vec128 = spu_shuffle( xyz->vec128, spu_promote( _w, 0 ), _VECTORMATH_SHUF_XYZA );
|
||||
}
|
||||
|
||||
static inline void vmathQMakeFromV4( VmathQuat *result, const VmathVector4 *vec )
|
||||
{
|
||||
result->vec128 = vec->vec128;
|
||||
}
|
||||
|
||||
static inline void vmathQMakeFromScalar( VmathQuat *result, float scalar )
|
||||
{
|
||||
result->vec128 = spu_splats( scalar );
|
||||
}
|
||||
|
||||
static inline void vmathQMakeFrom128( VmathQuat *result, vec_float4 vf4 )
|
||||
{
|
||||
result->vec128 = vf4;
|
||||
}
|
||||
|
||||
static inline void vmathQMakeIdentity( VmathQuat *result )
|
||||
{
|
||||
result->vec128 = _VECTORMATH_UNIT_0001;
|
||||
}
|
||||
|
||||
static inline void vmathQLerp( VmathQuat *result, float t, const VmathQuat *quat0, const VmathQuat *quat1 )
|
||||
{
|
||||
VmathQuat tmpQ_0, tmpQ_1;
|
||||
vmathQSub( &tmpQ_0, quat1, quat0 );
|
||||
vmathQScalarMul( &tmpQ_1, &tmpQ_0, t );
|
||||
vmathQAdd( result, quat0, &tmpQ_1 );
|
||||
}
|
||||
|
||||
static inline void vmathQSlerp( VmathQuat *result, float t, const VmathQuat *unitQuat0, const VmathQuat *unitQuat1 )
|
||||
{
|
||||
VmathQuat start;
|
||||
vec_float4 scales, scale0, scale1, cosAngle, angle, tttt, oneMinusT, angles, sines;
|
||||
vec_uint4 selectMask;
|
||||
vec_uchar16 shuffle_xxxx = (vec_uchar16)spu_splats((int)0x00010203);
|
||||
vec_uchar16 shuffle_yyyy = (vec_uchar16)spu_splats((int)0x04050607);
|
||||
vec_uchar16 shuffle_zzzz = (vec_uchar16)spu_splats((int)0x08090a0b);
|
||||
cosAngle = _vmathVfDot4( unitQuat0->vec128, unitQuat1->vec128 );
|
||||
cosAngle = spu_shuffle( cosAngle, cosAngle, shuffle_xxxx );
|
||||
selectMask = (vec_uint4)spu_cmpgt( spu_splats(0.0f), cosAngle );
|
||||
cosAngle = spu_sel( cosAngle, negatef4( cosAngle ), selectMask );
|
||||
start.vec128 = spu_sel( unitQuat0->vec128, negatef4( unitQuat0->vec128 ), selectMask );
|
||||
selectMask = (vec_uint4)spu_cmpgt( spu_splats(_VECTORMATH_SLERP_TOL), cosAngle );
|
||||
angle = acosf4( cosAngle );
|
||||
tttt = spu_splats(t);
|
||||
oneMinusT = spu_sub( spu_splats(1.0f), tttt );
|
||||
angles = spu_sel( spu_splats(1.0f), oneMinusT, (vec_uint4)spu_maskb(0x0f00) );
|
||||
angles = spu_sel( angles, tttt, (vec_uint4)spu_maskb(0x00f0) );
|
||||
angles = spu_mul( angles, angle );
|
||||
sines = sinf4( angles );
|
||||
scales = divf4( sines, spu_shuffle( sines, sines, shuffle_xxxx ) );
|
||||
scale0 = spu_sel( oneMinusT, spu_shuffle( scales, scales, shuffle_yyyy ), selectMask );
|
||||
scale1 = spu_sel( tttt, spu_shuffle( scales, scales, shuffle_zzzz ), selectMask );
|
||||
result->vec128 = spu_madd( start.vec128, scale0, spu_mul( unitQuat1->vec128, scale1 ) );
|
||||
}
|
||||
|
||||
static inline void vmathQSquad( VmathQuat *result, float t, const VmathQuat *unitQuat0, const VmathQuat *unitQuat1, const VmathQuat *unitQuat2, const VmathQuat *unitQuat3 )
|
||||
{
|
||||
VmathQuat tmp0, tmp1;
|
||||
vmathQSlerp( &tmp0, t, unitQuat0, unitQuat3 );
|
||||
vmathQSlerp( &tmp1, t, unitQuat1, unitQuat2 );
|
||||
vmathQSlerp( result, ( ( 2.0f * t ) * ( 1.0f - t ) ), &tmp0, &tmp1 );
|
||||
}
|
||||
|
||||
static inline vec_float4 vmathQGet128( const VmathQuat *quat )
|
||||
{
|
||||
return quat->vec128;
|
||||
}
|
||||
|
||||
static inline void vmathQSetXYZ( VmathQuat *result, const VmathVector3 *vec )
|
||||
{
|
||||
result->vec128 = spu_sel( vec->vec128, result->vec128, (vec_uint4)spu_maskb(0x000f) );
|
||||
}
|
||||
|
||||
static inline void vmathQGetXYZ( VmathVector3 *result, const VmathQuat *quat )
|
||||
{
|
||||
result->vec128 = quat->vec128;
|
||||
}
|
||||
|
||||
static inline void vmathQSetX( VmathQuat *result, float _x )
|
||||
{
|
||||
result->vec128 = spu_insert( _x, result->vec128, 0 );
|
||||
}
|
||||
|
||||
static inline float vmathQGetX( const VmathQuat *quat )
|
||||
{
|
||||
return spu_extract( quat->vec128, 0 );
|
||||
}
|
||||
|
||||
static inline void vmathQSetY( VmathQuat *result, float _y )
|
||||
{
|
||||
result->vec128 = spu_insert( _y, result->vec128, 1 );
|
||||
}
|
||||
|
||||
static inline float vmathQGetY( const VmathQuat *quat )
|
||||
{
|
||||
return spu_extract( quat->vec128, 1 );
|
||||
}
|
||||
|
||||
static inline void vmathQSetZ( VmathQuat *result, float _z )
|
||||
{
|
||||
result->vec128 = spu_insert( _z, result->vec128, 2 );
|
||||
}
|
||||
|
||||
static inline float vmathQGetZ( const VmathQuat *quat )
|
||||
{
|
||||
return spu_extract( quat->vec128, 2 );
|
||||
}
|
||||
|
||||
static inline void vmathQSetW( VmathQuat *result, float _w )
|
||||
{
|
||||
result->vec128 = spu_insert( _w, result->vec128, 3 );
|
||||
}
|
||||
|
||||
static inline float vmathQGetW( const VmathQuat *quat )
|
||||
{
|
||||
return spu_extract( quat->vec128, 3 );
|
||||
}
|
||||
|
||||
static inline void vmathQSetElem( VmathQuat *result, int idx, float value )
|
||||
{
|
||||
result->vec128 = spu_insert( value, result->vec128, idx );
|
||||
}
|
||||
|
||||
static inline float vmathQGetElem( const VmathQuat *quat, int idx )
|
||||
{
|
||||
return spu_extract( quat->vec128, idx );
|
||||
}
|
||||
|
||||
static inline void vmathQAdd( VmathQuat *result, const VmathQuat *quat0, const VmathQuat *quat1 )
|
||||
{
|
||||
result->vec128 = spu_add( quat0->vec128, quat1->vec128 );
|
||||
}
|
||||
|
||||
static inline void vmathQSub( VmathQuat *result, const VmathQuat *quat0, const VmathQuat *quat1 )
|
||||
{
|
||||
result->vec128 = spu_sub( quat0->vec128, quat1->vec128 );
|
||||
}
|
||||
|
||||
static inline void vmathQScalarMul( VmathQuat *result, const VmathQuat *quat, float scalar )
|
||||
{
|
||||
result->vec128 = spu_mul( quat->vec128, spu_splats(scalar) );
|
||||
}
|
||||
|
||||
static inline void vmathQScalarDiv( VmathQuat *result, const VmathQuat *quat, float scalar )
|
||||
{
|
||||
result->vec128 = divf4( quat->vec128, spu_splats(scalar) );
|
||||
}
|
||||
|
||||
static inline void vmathQNeg( VmathQuat *result, const VmathQuat *quat )
|
||||
{
|
||||
result->vec128 = negatef4( quat->vec128 );
|
||||
}
|
||||
|
||||
static inline float vmathQDot( const VmathQuat *quat0, const VmathQuat *quat1 )
|
||||
{
|
||||
return spu_extract( _vmathVfDot4( quat0->vec128, quat1->vec128 ), 0 );
|
||||
}
|
||||
|
||||
static inline float vmathQNorm( const VmathQuat *quat )
|
||||
{
|
||||
return spu_extract( _vmathVfDot4( quat->vec128, quat->vec128 ), 0 );
|
||||
}
|
||||
|
||||
static inline float vmathQLength( const VmathQuat *quat )
|
||||
{
|
||||
return sqrtf( vmathQNorm( quat ) );
|
||||
}
|
||||
|
||||
static inline void vmathQNormalize( VmathQuat *result, const VmathQuat *quat )
|
||||
{
|
||||
vec_float4 dot = _vmathVfDot4( quat->vec128, quat->vec128 );
|
||||
result->vec128 = spu_mul( quat->vec128, rsqrtf4( dot ) );
|
||||
}
|
||||
|
||||
static inline void vmathQMakeRotationArc( VmathQuat *result, const VmathVector3 *unitVec0, const VmathVector3 *unitVec1 )
|
||||
{
|
||||
VmathVector3 crossVec, tmpV3_0;
|
||||
vec_float4 cosAngle, cosAngleX2Plus2, recipCosHalfAngleX2, cosHalfAngleX2, res;
|
||||
cosAngle = _vmathVfDot3( unitVec0->vec128, unitVec1->vec128 );
|
||||
cosAngle = spu_shuffle( cosAngle, cosAngle, (vec_uchar16)spu_splats(0x00010203) );
|
||||
cosAngleX2Plus2 = spu_madd( cosAngle, spu_splats(2.0f), spu_splats(2.0f) );
|
||||
recipCosHalfAngleX2 = rsqrtf4( cosAngleX2Plus2 );
|
||||
cosHalfAngleX2 = spu_mul( recipCosHalfAngleX2, cosAngleX2Plus2 );
|
||||
vmathV3Cross( &tmpV3_0, unitVec0, unitVec1 );
|
||||
crossVec = tmpV3_0;
|
||||
res = spu_mul( crossVec.vec128, recipCosHalfAngleX2 );
|
||||
res = spu_sel( res, spu_mul( cosHalfAngleX2, spu_splats(0.5f) ), (vec_uint4)spu_maskb(0x000f) );
|
||||
result->vec128 = res;
|
||||
}
|
||||
|
||||
static inline void vmathQMakeRotationAxis( VmathQuat *result, float radians, const VmathVector3 *unitVec )
|
||||
{
|
||||
vec_float4 s, c, angle, res;
|
||||
angle = spu_mul( spu_splats(radians), spu_splats(0.5f) );
|
||||
sincosf4( angle, &s, &c );
|
||||
res = spu_sel( spu_mul( unitVec->vec128, s ), c, (vec_uint4)spu_maskb(0x000f) );
|
||||
result->vec128 = res;
|
||||
}
|
||||
|
||||
static inline void vmathQMakeRotationX( VmathQuat *result, float radians )
|
||||
{
|
||||
vec_float4 s, c, angle, res;
|
||||
angle = spu_mul( spu_splats(radians), spu_splats(0.5f) );
|
||||
sincosf4( angle, &s, &c );
|
||||
res = spu_sel( spu_splats(0.0f), s, (vec_uint4)spu_maskb(0xf000) );
|
||||
res = spu_sel( res, c, (vec_uint4)spu_maskb(0x000f) );
|
||||
result->vec128 = res;
|
||||
}
|
||||
|
||||
static inline void vmathQMakeRotationY( VmathQuat *result, float radians )
|
||||
{
|
||||
vec_float4 s, c, angle, res;
|
||||
angle = spu_mul( spu_splats(radians), spu_splats(0.5f) );
|
||||
sincosf4( angle, &s, &c );
|
||||
res = spu_sel( spu_splats(0.0f), s, (vec_uint4)spu_maskb(0x0f00) );
|
||||
res = spu_sel( res, c, (vec_uint4)spu_maskb(0x000f) );
|
||||
result->vec128 = res;
|
||||
}
|
||||
|
||||
static inline void vmathQMakeRotationZ( VmathQuat *result, float radians )
|
||||
{
|
||||
vec_float4 s, c, angle, res;
|
||||
angle = spu_mul( spu_splats(radians), spu_splats(0.5f) );
|
||||
sincosf4( angle, &s, &c );
|
||||
res = spu_sel( spu_splats(0.0f), s, (vec_uint4)spu_maskb(0x00f0) );
|
||||
res = spu_sel( res, c, (vec_uint4)spu_maskb(0x000f) );
|
||||
result->vec128 = res;
|
||||
}
|
||||
|
||||
static inline void vmathQMul( VmathQuat *result, const VmathQuat *quat0, const VmathQuat *quat1 )
|
||||
{
|
||||
vec_float4 ldata, rdata, qv, tmp0, tmp1, tmp2, tmp3;
|
||||
vec_float4 product, l_wxyz, r_wxyz, xy, qw;
|
||||
ldata = quat0->vec128;
|
||||
rdata = quat1->vec128;
|
||||
vec_uchar16 shuffle_wwww = (vec_uchar16)spu_splats((int)0x0c0d0e0f);
|
||||
tmp0 = spu_shuffle( ldata, ldata, _VECTORMATH_SHUF_YZXW );
|
||||
tmp1 = spu_shuffle( rdata, rdata, _VECTORMATH_SHUF_ZXYW );
|
||||
tmp2 = spu_shuffle( ldata, ldata, _VECTORMATH_SHUF_ZXYW );
|
||||
tmp3 = spu_shuffle( rdata, rdata, _VECTORMATH_SHUF_YZXW );
|
||||
qv = spu_mul( spu_shuffle( ldata, ldata, shuffle_wwww ), rdata );
|
||||
qv = spu_madd( spu_shuffle( rdata, rdata, shuffle_wwww ), ldata, qv );
|
||||
qv = spu_madd( tmp0, tmp1, qv );
|
||||
qv = spu_nmsub( tmp2, tmp3, qv );
|
||||
product = spu_mul( ldata, rdata );
|
||||
l_wxyz = spu_rlqwbyte( ldata, 12 );
|
||||
r_wxyz = spu_rlqwbyte( rdata, 12 );
|
||||
qw = spu_nmsub( l_wxyz, r_wxyz, product );
|
||||
xy = spu_madd( l_wxyz, r_wxyz, product );
|
||||
qw = spu_sub( qw, spu_rlqwbyte( xy, 8 ) );
|
||||
result->vec128 = spu_sel( qv, qw, (vec_uint4)spu_maskb( 0x000f ) );
|
||||
}
|
||||
|
||||
static inline void vmathQRotate( VmathVector3 *result, const VmathQuat *quat, const VmathVector3 *vec )
|
||||
{
|
||||
vec_float4 qdata, vdata, product, tmp0, tmp1, tmp2, tmp3, wwww, qv, qw, res;
|
||||
qdata = quat->vec128;
|
||||
vdata = vec->vec128;
|
||||
vec_uchar16 shuffle_xxxx = (vec_uchar16)spu_splats((int)0x00010203);
|
||||
vec_uchar16 shuffle_wwww = (vec_uchar16)spu_splats((int)0x0c0d0e0f);
|
||||
tmp0 = spu_shuffle( qdata, qdata, _VECTORMATH_SHUF_YZXW );
|
||||
tmp1 = spu_shuffle( vdata, vdata, _VECTORMATH_SHUF_ZXYW );
|
||||
tmp2 = spu_shuffle( qdata, qdata, _VECTORMATH_SHUF_ZXYW );
|
||||
tmp3 = spu_shuffle( vdata, vdata, _VECTORMATH_SHUF_YZXW );
|
||||
wwww = spu_shuffle( qdata, qdata, shuffle_wwww );
|
||||
qv = spu_mul( wwww, vdata );
|
||||
qv = spu_madd( tmp0, tmp1, qv );
|
||||
qv = spu_nmsub( tmp2, tmp3, qv );
|
||||
product = spu_mul( qdata, vdata );
|
||||
qw = spu_madd( spu_rlqwbyte( qdata, 4 ), spu_rlqwbyte( vdata, 4 ), product );
|
||||
qw = spu_add( spu_rlqwbyte( product, 8 ), qw );
|
||||
tmp1 = spu_shuffle( qv, qv, _VECTORMATH_SHUF_ZXYW );
|
||||
tmp3 = spu_shuffle( qv, qv, _VECTORMATH_SHUF_YZXW );
|
||||
res = spu_mul( spu_shuffle( qw, qw, shuffle_xxxx ), qdata );
|
||||
res = spu_madd( wwww, qv, res );
|
||||
res = spu_madd( tmp0, tmp1, res );
|
||||
res = spu_nmsub( tmp2, tmp3, res );
|
||||
result->vec128 = res;
|
||||
}
|
||||
|
||||
static inline void vmathQConj( VmathQuat *result, const VmathQuat *quat )
|
||||
{
|
||||
result->vec128 = spu_xor( quat->vec128, ((vec_float4)(vec_int4){0x80000000,0x80000000,0x80000000,0}) );
|
||||
}
|
||||
|
||||
static inline void vmathQSelect( VmathQuat *result, const VmathQuat *quat0, const VmathQuat *quat1, unsigned int select1 )
|
||||
{
|
||||
result->vec128 = spu_sel( quat0->vec128, quat1->vec128, spu_splats( (unsigned int)-(select1 > 0) ) );
|
||||
}
|
||||
|
||||
#ifdef _VECTORMATH_DEBUG
|
||||
|
||||
static inline void vmathQPrint( const VmathQuat *quat )
|
||||
{
|
||||
union { vec_float4 v; float s[4]; } tmp;
|
||||
tmp.v = quat->vec128;
|
||||
printf( "( %f %f %f %f )\n", tmp.s[0], tmp.s[1], tmp.s[2], tmp.s[3] );
|
||||
}
|
||||
|
||||
static inline void vmathQPrints( const VmathQuat *quat, const char *name )
|
||||
{
|
||||
union { vec_float4 v; float s[4]; } tmp;
|
||||
tmp.v = quat->vec128;
|
||||
printf( "%s: ( %f %f %f %f )\n", name, tmp.s[0], tmp.s[1], tmp.s[2], tmp.s[3] );
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#endif
|
||||
312
Extras/vectormathlibrary/include/vectormath/spu/c/quat_aos_v.h
Normal file
312
Extras/vectormathlibrary/include/vectormath/spu/c/quat_aos_v.h
Normal file
@@ -0,0 +1,312 @@
|
||||
/*
|
||||
Copyright (C) 2006, 2007 Sony Computer Entertainment Inc.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms,
|
||||
with or without modification, are permitted provided that the
|
||||
following conditions are met:
|
||||
* Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
* Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in the
|
||||
documentation and/or other materials provided with the distribution.
|
||||
* Neither the name of the Sony Computer Entertainment Inc nor the names
|
||||
of its contributors may be used to endorse or promote products derived
|
||||
from this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
||||
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#ifndef _VECTORMATH_QUAT_AOS_V_C_H
|
||||
#define _VECTORMATH_QUAT_AOS_V_C_H
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif /* __cplusplus */
|
||||
|
||||
/*-----------------------------------------------------------------------------
|
||||
* Definitions
|
||||
*/
|
||||
#ifndef _VECTORMATH_INTERNAL_FUNCTIONS
|
||||
#define _VECTORMATH_INTERNAL_FUNCTIONS
|
||||
|
||||
#endif
|
||||
|
||||
static inline VmathQuat vmathQMakeFromElems_V( float _x, float _y, float _z, float _w )
|
||||
{
|
||||
VmathQuat result;
|
||||
vmathQMakeFromElems(&result, _x, _y, _z, _w);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathQuat vmathQMakeFromV3Scalar_V( VmathVector3 xyz, float _w )
|
||||
{
|
||||
VmathQuat result;
|
||||
vmathQMakeFromV3Scalar(&result, &xyz, _w);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathQuat vmathQMakeFromV4_V( VmathVector4 vec )
|
||||
{
|
||||
VmathQuat result;
|
||||
vmathQMakeFromV4(&result, &vec);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathQuat vmathQMakeFromScalar_V( float scalar )
|
||||
{
|
||||
VmathQuat result;
|
||||
vmathQMakeFromScalar(&result, scalar);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathQuat vmathQMakeFrom128_V( vec_float4 vf4 )
|
||||
{
|
||||
VmathQuat result;
|
||||
vmathQMakeFrom128(&result, vf4);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathQuat vmathQMakeIdentity_V( )
|
||||
{
|
||||
VmathQuat result;
|
||||
vmathQMakeIdentity(&result);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathQuat vmathQLerp_V( float t, VmathQuat quat0, VmathQuat quat1 )
|
||||
{
|
||||
VmathQuat result;
|
||||
vmathQLerp(&result, t, &quat0, &quat1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathQuat vmathQSlerp_V( float t, VmathQuat unitQuat0, VmathQuat unitQuat1 )
|
||||
{
|
||||
VmathQuat result;
|
||||
vmathQSlerp(&result, t, &unitQuat0, &unitQuat1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathQuat vmathQSquad_V( float t, VmathQuat unitQuat0, VmathQuat unitQuat1, VmathQuat unitQuat2, VmathQuat unitQuat3 )
|
||||
{
|
||||
VmathQuat result;
|
||||
vmathQSquad(&result, t, &unitQuat0, &unitQuat1, &unitQuat2, &unitQuat3);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline vec_float4 vmathQGet128_V( VmathQuat quat )
|
||||
{
|
||||
return vmathQGet128(&quat);
|
||||
}
|
||||
|
||||
static inline void vmathQSetXYZ_V( VmathQuat *result, VmathVector3 vec )
|
||||
{
|
||||
vmathQSetXYZ(result, &vec);
|
||||
}
|
||||
|
||||
static inline VmathVector3 vmathQGetXYZ_V( VmathQuat quat )
|
||||
{
|
||||
VmathVector3 result;
|
||||
vmathQGetXYZ(&result, &quat);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline void vmathQSetX_V( VmathQuat *result, float _x )
|
||||
{
|
||||
vmathQSetX(result, _x);
|
||||
}
|
||||
|
||||
static inline float vmathQGetX_V( VmathQuat quat )
|
||||
{
|
||||
return vmathQGetX(&quat);
|
||||
}
|
||||
|
||||
static inline void vmathQSetY_V( VmathQuat *result, float _y )
|
||||
{
|
||||
vmathQSetY(result, _y);
|
||||
}
|
||||
|
||||
static inline float vmathQGetY_V( VmathQuat quat )
|
||||
{
|
||||
return vmathQGetY(&quat);
|
||||
}
|
||||
|
||||
static inline void vmathQSetZ_V( VmathQuat *result, float _z )
|
||||
{
|
||||
vmathQSetZ(result, _z);
|
||||
}
|
||||
|
||||
static inline float vmathQGetZ_V( VmathQuat quat )
|
||||
{
|
||||
return vmathQGetZ(&quat);
|
||||
}
|
||||
|
||||
static inline void vmathQSetW_V( VmathQuat *result, float _w )
|
||||
{
|
||||
vmathQSetW(result, _w);
|
||||
}
|
||||
|
||||
static inline float vmathQGetW_V( VmathQuat quat )
|
||||
{
|
||||
return vmathQGetW(&quat);
|
||||
}
|
||||
|
||||
static inline void vmathQSetElem_V( VmathQuat *result, int idx, float value )
|
||||
{
|
||||
vmathQSetElem(result, idx, value);
|
||||
}
|
||||
|
||||
static inline float vmathQGetElem_V( VmathQuat quat, int idx )
|
||||
{
|
||||
return vmathQGetElem(&quat, idx);
|
||||
}
|
||||
|
||||
static inline VmathQuat vmathQAdd_V( VmathQuat quat0, VmathQuat quat1 )
|
||||
{
|
||||
VmathQuat result;
|
||||
vmathQAdd(&result, &quat0, &quat1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathQuat vmathQSub_V( VmathQuat quat0, VmathQuat quat1 )
|
||||
{
|
||||
VmathQuat result;
|
||||
vmathQSub(&result, &quat0, &quat1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathQuat vmathQScalarMul_V( VmathQuat quat, float scalar )
|
||||
{
|
||||
VmathQuat result;
|
||||
vmathQScalarMul(&result, &quat, scalar);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathQuat vmathQScalarDiv_V( VmathQuat quat, float scalar )
|
||||
{
|
||||
VmathQuat result;
|
||||
vmathQScalarDiv(&result, &quat, scalar);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathQuat vmathQNeg_V( VmathQuat quat )
|
||||
{
|
||||
VmathQuat result;
|
||||
vmathQNeg(&result, &quat);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline float vmathQDot_V( VmathQuat quat0, VmathQuat quat1 )
|
||||
{
|
||||
return vmathQDot(&quat0, &quat1);
|
||||
}
|
||||
|
||||
static inline float vmathQNorm_V( VmathQuat quat )
|
||||
{
|
||||
return vmathQNorm(&quat);
|
||||
}
|
||||
|
||||
static inline float vmathQLength_V( VmathQuat quat )
|
||||
{
|
||||
return vmathQLength(&quat);
|
||||
}
|
||||
|
||||
static inline VmathQuat vmathQNormalize_V( VmathQuat quat )
|
||||
{
|
||||
VmathQuat result;
|
||||
vmathQNormalize(&result, &quat);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathQuat vmathQMakeRotationArc_V( VmathVector3 unitVec0, VmathVector3 unitVec1 )
|
||||
{
|
||||
VmathQuat result;
|
||||
vmathQMakeRotationArc(&result, &unitVec0, &unitVec1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathQuat vmathQMakeRotationAxis_V( float radians, VmathVector3 unitVec )
|
||||
{
|
||||
VmathQuat result;
|
||||
vmathQMakeRotationAxis(&result, radians, &unitVec);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathQuat vmathQMakeRotationX_V( float radians )
|
||||
{
|
||||
VmathQuat result;
|
||||
vmathQMakeRotationX(&result, radians);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathQuat vmathQMakeRotationY_V( float radians )
|
||||
{
|
||||
VmathQuat result;
|
||||
vmathQMakeRotationY(&result, radians);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathQuat vmathQMakeRotationZ_V( float radians )
|
||||
{
|
||||
VmathQuat result;
|
||||
vmathQMakeRotationZ(&result, radians);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathQuat vmathQMul_V( VmathQuat quat0, VmathQuat quat1 )
|
||||
{
|
||||
VmathQuat result;
|
||||
vmathQMul(&result, &quat0, &quat1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathVector3 vmathQRotate_V( VmathQuat quat, VmathVector3 vec )
|
||||
{
|
||||
VmathVector3 result;
|
||||
vmathQRotate(&result, &quat, &vec);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathQuat vmathQConj_V( VmathQuat quat )
|
||||
{
|
||||
VmathQuat result;
|
||||
vmathQConj(&result, &quat);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathQuat vmathQSelect_V( VmathQuat quat0, VmathQuat quat1, unsigned int select1 )
|
||||
{
|
||||
VmathQuat result;
|
||||
vmathQSelect(&result, &quat0, &quat1, select1);
|
||||
return result;
|
||||
}
|
||||
|
||||
#ifdef _VECTORMATH_DEBUG
|
||||
|
||||
static inline void vmathQPrint_V( VmathQuat quat )
|
||||
{
|
||||
vmathQPrint(&quat);
|
||||
}
|
||||
|
||||
static inline void vmathQPrints_V( VmathQuat quat, const char *name )
|
||||
{
|
||||
vmathQPrints(&quat, name);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#endif
|
||||
419
Extras/vectormathlibrary/include/vectormath/spu/c/quat_soa.h
Normal file
419
Extras/vectormathlibrary/include/vectormath/spu/c/quat_soa.h
Normal file
@@ -0,0 +1,419 @@
|
||||
/*
|
||||
Copyright (C) 2006, 2007 Sony Computer Entertainment Inc.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms,
|
||||
with or without modification, are permitted provided that the
|
||||
following conditions are met:
|
||||
* Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
* Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in the
|
||||
documentation and/or other materials provided with the distribution.
|
||||
* Neither the name of the Sony Computer Entertainment Inc nor the names
|
||||
of its contributors may be used to endorse or promote products derived
|
||||
from this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
||||
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#ifndef _VECTORMATH_QUAT_SOA_C_H
|
||||
#define _VECTORMATH_QUAT_SOA_C_H
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif /* __cplusplus */
|
||||
|
||||
/*-----------------------------------------------------------------------------
|
||||
* Definitions
|
||||
*/
|
||||
#ifndef _VECTORMATH_INTERNAL_FUNCTIONS
|
||||
#define _VECTORMATH_INTERNAL_FUNCTIONS
|
||||
|
||||
#endif
|
||||
|
||||
static inline void vmathSoaQCopy( VmathSoaQuat *result, const VmathSoaQuat *quat )
|
||||
{
|
||||
result->x = quat->x;
|
||||
result->y = quat->y;
|
||||
result->z = quat->z;
|
||||
result->w = quat->w;
|
||||
}
|
||||
|
||||
static inline void vmathSoaQMakeFromElems( VmathSoaQuat *result, vec_float4 _x, vec_float4 _y, vec_float4 _z, vec_float4 _w )
|
||||
{
|
||||
result->x = _x;
|
||||
result->y = _y;
|
||||
result->z = _z;
|
||||
result->w = _w;
|
||||
}
|
||||
|
||||
static inline void vmathSoaQMakeFromV3Scalar( VmathSoaQuat *result, const VmathSoaVector3 *xyz, vec_float4 _w )
|
||||
{
|
||||
vmathSoaQSetXYZ( result, xyz );
|
||||
vmathSoaQSetW( result, _w );
|
||||
}
|
||||
|
||||
static inline void vmathSoaQMakeFromV4( VmathSoaQuat *result, const VmathSoaVector4 *vec )
|
||||
{
|
||||
result->x = vec->x;
|
||||
result->y = vec->y;
|
||||
result->z = vec->z;
|
||||
result->w = vec->w;
|
||||
}
|
||||
|
||||
static inline void vmathSoaQMakeFromScalar( VmathSoaQuat *result, vec_float4 scalar )
|
||||
{
|
||||
result->x = scalar;
|
||||
result->y = scalar;
|
||||
result->z = scalar;
|
||||
result->w = scalar;
|
||||
}
|
||||
|
||||
static inline void vmathSoaQMakeFromAos( VmathSoaQuat *result, const VmathQuat *quat )
|
||||
{
|
||||
vec_uchar16 shuffle_xxxx = (vec_uchar16)spu_splats((int)0x00010203);
|
||||
vec_uchar16 shuffle_yyyy = (vec_uchar16)spu_splats((int)0x04050607);
|
||||
vec_uchar16 shuffle_zzzz = (vec_uchar16)spu_splats((int)0x08090a0b);
|
||||
vec_uchar16 shuffle_wwww = (vec_uchar16)spu_splats((int)0x0c0d0e0f);
|
||||
vec_float4 vec128 = quat->vec128;
|
||||
result->x = spu_shuffle( vec128, vec128, shuffle_xxxx );
|
||||
result->y = spu_shuffle( vec128, vec128, shuffle_yyyy );
|
||||
result->z = spu_shuffle( vec128, vec128, shuffle_zzzz );
|
||||
result->w = spu_shuffle( vec128, vec128, shuffle_wwww );
|
||||
}
|
||||
|
||||
static inline void vmathSoaQMakeFrom4Aos( VmathSoaQuat *result, const VmathQuat *quat0, const VmathQuat *quat1, const VmathQuat *quat2, const VmathQuat *quat3 )
|
||||
{
|
||||
vec_float4 tmp0, tmp1, tmp2, tmp3;
|
||||
tmp0 = spu_shuffle( quat0->vec128, quat2->vec128, _VECTORMATH_SHUF_XAYB );
|
||||
tmp1 = spu_shuffle( quat1->vec128, quat3->vec128, _VECTORMATH_SHUF_XAYB );
|
||||
tmp2 = spu_shuffle( quat0->vec128, quat2->vec128, _VECTORMATH_SHUF_ZCWD );
|
||||
tmp3 = spu_shuffle( quat1->vec128, quat3->vec128, _VECTORMATH_SHUF_ZCWD );
|
||||
result->x = spu_shuffle( tmp0, tmp1, _VECTORMATH_SHUF_XAYB );
|
||||
result->y = spu_shuffle( tmp0, tmp1, _VECTORMATH_SHUF_ZCWD );
|
||||
result->z = spu_shuffle( tmp2, tmp3, _VECTORMATH_SHUF_XAYB );
|
||||
result->w = spu_shuffle( tmp2, tmp3, _VECTORMATH_SHUF_ZCWD );
|
||||
}
|
||||
|
||||
static inline void vmathSoaQMakeIdentity( VmathSoaQuat *result )
|
||||
{
|
||||
vmathSoaQMakeFromElems( result, spu_splats(0.0f), spu_splats(0.0f), spu_splats(0.0f), spu_splats(1.0f) );
|
||||
}
|
||||
|
||||
static inline void vmathSoaQLerp( VmathSoaQuat *result, vec_float4 t, const VmathSoaQuat *quat0, const VmathSoaQuat *quat1 )
|
||||
{
|
||||
VmathSoaQuat tmpQ_0, tmpQ_1;
|
||||
vmathSoaQSub( &tmpQ_0, quat1, quat0 );
|
||||
vmathSoaQScalarMul( &tmpQ_1, &tmpQ_0, t );
|
||||
vmathSoaQAdd( result, quat0, &tmpQ_1 );
|
||||
}
|
||||
|
||||
static inline void vmathSoaQSlerp( VmathSoaQuat *result, vec_float4 t, const VmathSoaQuat *unitQuat0, const VmathSoaQuat *unitQuat1 )
|
||||
{
|
||||
VmathSoaQuat start, tmpQ_0, tmpQ_1;
|
||||
vec_float4 recipSinAngle, scale0, scale1, cosAngle, angle;
|
||||
vec_uint4 selectMask;
|
||||
cosAngle = vmathSoaQDot( unitQuat0, unitQuat1 );
|
||||
selectMask = (vec_uint4)spu_cmpgt( spu_splats(0.0f), cosAngle );
|
||||
cosAngle = spu_sel( cosAngle, negatef4( cosAngle ), selectMask );
|
||||
vmathSoaQSetX( &start, spu_sel( unitQuat0->x, negatef4( unitQuat0->x ), selectMask ) );
|
||||
vmathSoaQSetY( &start, spu_sel( unitQuat0->y, negatef4( unitQuat0->y ), selectMask ) );
|
||||
vmathSoaQSetZ( &start, spu_sel( unitQuat0->z, negatef4( unitQuat0->z ), selectMask ) );
|
||||
vmathSoaQSetW( &start, spu_sel( unitQuat0->w, negatef4( unitQuat0->w ), selectMask ) );
|
||||
selectMask = (vec_uint4)spu_cmpgt( spu_splats(_VECTORMATH_SLERP_TOL), cosAngle );
|
||||
angle = acosf4( cosAngle );
|
||||
recipSinAngle = recipf4( sinf4( angle ) );
|
||||
scale0 = spu_sel( spu_sub( spu_splats(1.0f), t ), spu_mul( sinf4( spu_mul( spu_sub( spu_splats(1.0f), t ), angle ) ), recipSinAngle ), selectMask );
|
||||
scale1 = spu_sel( t, spu_mul( sinf4( spu_mul( t, angle ) ), recipSinAngle ), selectMask );
|
||||
vmathSoaQScalarMul( &tmpQ_0, &start, scale0 );
|
||||
vmathSoaQScalarMul( &tmpQ_1, unitQuat1, scale1 );
|
||||
vmathSoaQAdd( result, &tmpQ_0, &tmpQ_1 );
|
||||
}
|
||||
|
||||
static inline void vmathSoaQSquad( VmathSoaQuat *result, vec_float4 t, const VmathSoaQuat *unitQuat0, const VmathSoaQuat *unitQuat1, const VmathSoaQuat *unitQuat2, const VmathSoaQuat *unitQuat3 )
|
||||
{
|
||||
VmathSoaQuat tmp0, tmp1;
|
||||
vmathSoaQSlerp( &tmp0, t, unitQuat0, unitQuat3 );
|
||||
vmathSoaQSlerp( &tmp1, t, unitQuat1, unitQuat2 );
|
||||
vmathSoaQSlerp( result, spu_mul( spu_mul( spu_splats(2.0f), t ), spu_sub( spu_splats(1.0f), t ) ), &tmp0, &tmp1 );
|
||||
}
|
||||
|
||||
static inline void vmathSoaQGet4Aos( const VmathSoaQuat *quat, VmathQuat *result0, VmathQuat *result1, VmathQuat *result2, VmathQuat *result3 )
|
||||
{
|
||||
vec_float4 tmp0, tmp1, tmp2, tmp3;
|
||||
tmp0 = spu_shuffle( quat->x, quat->z, _VECTORMATH_SHUF_XAYB );
|
||||
tmp1 = spu_shuffle( quat->y, quat->w, _VECTORMATH_SHUF_XAYB );
|
||||
tmp2 = spu_shuffle( quat->x, quat->z, _VECTORMATH_SHUF_ZCWD );
|
||||
tmp3 = spu_shuffle( quat->y, quat->w, _VECTORMATH_SHUF_ZCWD );
|
||||
vmathQMakeFrom128( result0, spu_shuffle( tmp0, tmp1, _VECTORMATH_SHUF_XAYB ) );
|
||||
vmathQMakeFrom128( result1, spu_shuffle( tmp0, tmp1, _VECTORMATH_SHUF_ZCWD ) );
|
||||
vmathQMakeFrom128( result2, spu_shuffle( tmp2, tmp3, _VECTORMATH_SHUF_XAYB ) );
|
||||
vmathQMakeFrom128( result3, spu_shuffle( tmp2, tmp3, _VECTORMATH_SHUF_ZCWD ) );
|
||||
}
|
||||
|
||||
static inline void vmathSoaQSetXYZ( VmathSoaQuat *result, const VmathSoaVector3 *vec )
|
||||
{
|
||||
result->x = vec->x;
|
||||
result->y = vec->y;
|
||||
result->z = vec->z;
|
||||
}
|
||||
|
||||
static inline void vmathSoaQGetXYZ( VmathSoaVector3 *result, const VmathSoaQuat *quat )
|
||||
{
|
||||
vmathSoaV3MakeFromElems( result, quat->x, quat->y, quat->z );
|
||||
}
|
||||
|
||||
static inline void vmathSoaQSetX( VmathSoaQuat *result, vec_float4 _x )
|
||||
{
|
||||
result->x = _x;
|
||||
}
|
||||
|
||||
static inline vec_float4 vmathSoaQGetX( const VmathSoaQuat *quat )
|
||||
{
|
||||
return quat->x;
|
||||
}
|
||||
|
||||
static inline void vmathSoaQSetY( VmathSoaQuat *result, vec_float4 _y )
|
||||
{
|
||||
result->y = _y;
|
||||
}
|
||||
|
||||
static inline vec_float4 vmathSoaQGetY( const VmathSoaQuat *quat )
|
||||
{
|
||||
return quat->y;
|
||||
}
|
||||
|
||||
static inline void vmathSoaQSetZ( VmathSoaQuat *result, vec_float4 _z )
|
||||
{
|
||||
result->z = _z;
|
||||
}
|
||||
|
||||
static inline vec_float4 vmathSoaQGetZ( const VmathSoaQuat *quat )
|
||||
{
|
||||
return quat->z;
|
||||
}
|
||||
|
||||
static inline void vmathSoaQSetW( VmathSoaQuat *result, vec_float4 _w )
|
||||
{
|
||||
result->w = _w;
|
||||
}
|
||||
|
||||
static inline vec_float4 vmathSoaQGetW( const VmathSoaQuat *quat )
|
||||
{
|
||||
return quat->w;
|
||||
}
|
||||
|
||||
static inline void vmathSoaQSetElem( VmathSoaQuat *result, int idx, vec_float4 value )
|
||||
{
|
||||
*(&result->x + idx) = value;
|
||||
}
|
||||
|
||||
static inline vec_float4 vmathSoaQGetElem( const VmathSoaQuat *quat, int idx )
|
||||
{
|
||||
return *(&quat->x + idx);
|
||||
}
|
||||
|
||||
static inline void vmathSoaQAdd( VmathSoaQuat *result, const VmathSoaQuat *quat0, const VmathSoaQuat *quat1 )
|
||||
{
|
||||
result->x = spu_add( quat0->x, quat1->x );
|
||||
result->y = spu_add( quat0->y, quat1->y );
|
||||
result->z = spu_add( quat0->z, quat1->z );
|
||||
result->w = spu_add( quat0->w, quat1->w );
|
||||
}
|
||||
|
||||
static inline void vmathSoaQSub( VmathSoaQuat *result, const VmathSoaQuat *quat0, const VmathSoaQuat *quat1 )
|
||||
{
|
||||
result->x = spu_sub( quat0->x, quat1->x );
|
||||
result->y = spu_sub( quat0->y, quat1->y );
|
||||
result->z = spu_sub( quat0->z, quat1->z );
|
||||
result->w = spu_sub( quat0->w, quat1->w );
|
||||
}
|
||||
|
||||
static inline void vmathSoaQScalarMul( VmathSoaQuat *result, const VmathSoaQuat *quat, vec_float4 scalar )
|
||||
{
|
||||
result->x = spu_mul( quat->x, scalar );
|
||||
result->y = spu_mul( quat->y, scalar );
|
||||
result->z = spu_mul( quat->z, scalar );
|
||||
result->w = spu_mul( quat->w, scalar );
|
||||
}
|
||||
|
||||
static inline void vmathSoaQScalarDiv( VmathSoaQuat *result, const VmathSoaQuat *quat, vec_float4 scalar )
|
||||
{
|
||||
result->x = divf4( quat->x, scalar );
|
||||
result->y = divf4( quat->y, scalar );
|
||||
result->z = divf4( quat->z, scalar );
|
||||
result->w = divf4( quat->w, scalar );
|
||||
}
|
||||
|
||||
static inline void vmathSoaQNeg( VmathSoaQuat *result, const VmathSoaQuat *quat )
|
||||
{
|
||||
result->x = negatef4( quat->x );
|
||||
result->y = negatef4( quat->y );
|
||||
result->z = negatef4( quat->z );
|
||||
result->w = negatef4( quat->w );
|
||||
}
|
||||
|
||||
static inline vec_float4 vmathSoaQDot( const VmathSoaQuat *quat0, const VmathSoaQuat *quat1 )
|
||||
{
|
||||
vec_float4 result;
|
||||
result = spu_mul( quat0->x, quat1->x );
|
||||
result = spu_add( result, spu_mul( quat0->y, quat1->y ) );
|
||||
result = spu_add( result, spu_mul( quat0->z, quat1->z ) );
|
||||
result = spu_add( result, spu_mul( quat0->w, quat1->w ) );
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline vec_float4 vmathSoaQNorm( const VmathSoaQuat *quat )
|
||||
{
|
||||
vec_float4 result;
|
||||
result = spu_mul( quat->x, quat->x );
|
||||
result = spu_add( result, spu_mul( quat->y, quat->y ) );
|
||||
result = spu_add( result, spu_mul( quat->z, quat->z ) );
|
||||
result = spu_add( result, spu_mul( quat->w, quat->w ) );
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline vec_float4 vmathSoaQLength( const VmathSoaQuat *quat )
|
||||
{
|
||||
return sqrtf4( vmathSoaQNorm( quat ) );
|
||||
}
|
||||
|
||||
static inline void vmathSoaQNormalize( VmathSoaQuat *result, const VmathSoaQuat *quat )
|
||||
{
|
||||
vec_float4 lenSqr, lenInv;
|
||||
lenSqr = vmathSoaQNorm( quat );
|
||||
lenInv = rsqrtf4( lenSqr );
|
||||
result->x = spu_mul( quat->x, lenInv );
|
||||
result->y = spu_mul( quat->y, lenInv );
|
||||
result->z = spu_mul( quat->z, lenInv );
|
||||
result->w = spu_mul( quat->w, lenInv );
|
||||
}
|
||||
|
||||
static inline void vmathSoaQMakeRotationArc( VmathSoaQuat *result, const VmathSoaVector3 *unitVec0, const VmathSoaVector3 *unitVec1 )
|
||||
{
|
||||
VmathSoaVector3 tmpV3_0, tmpV3_1;
|
||||
vec_float4 cosHalfAngleX2, recipCosHalfAngleX2;
|
||||
cosHalfAngleX2 = sqrtf4( spu_mul( spu_splats(2.0f), spu_add( spu_splats(1.0f), vmathSoaV3Dot( unitVec0, unitVec1 ) ) ) );
|
||||
recipCosHalfAngleX2 = recipf4( cosHalfAngleX2 );
|
||||
vmathSoaV3Cross( &tmpV3_0, unitVec0, unitVec1 );
|
||||
vmathSoaV3ScalarMul( &tmpV3_1, &tmpV3_0, recipCosHalfAngleX2 );
|
||||
vmathSoaQMakeFromV3Scalar( result, &tmpV3_1, spu_mul( cosHalfAngleX2, spu_splats(0.5f) ) );
|
||||
}
|
||||
|
||||
static inline void vmathSoaQMakeRotationAxis( VmathSoaQuat *result, vec_float4 radians, const VmathSoaVector3 *unitVec )
|
||||
{
|
||||
VmathSoaVector3 tmpV3_0;
|
||||
vec_float4 s, c, angle;
|
||||
angle = spu_mul( radians, spu_splats(0.5f) );
|
||||
sincosf4( angle, &s, &c );
|
||||
vmathSoaV3ScalarMul( &tmpV3_0, unitVec, s );
|
||||
vmathSoaQMakeFromV3Scalar( result, &tmpV3_0, c );
|
||||
}
|
||||
|
||||
static inline void vmathSoaQMakeRotationX( VmathSoaQuat *result, vec_float4 radians )
|
||||
{
|
||||
vec_float4 s, c, angle;
|
||||
angle = spu_mul( radians, spu_splats(0.5f) );
|
||||
sincosf4( angle, &s, &c );
|
||||
vmathSoaQMakeFromElems( result, s, spu_splats(0.0f), spu_splats(0.0f), c );
|
||||
}
|
||||
|
||||
static inline void vmathSoaQMakeRotationY( VmathSoaQuat *result, vec_float4 radians )
|
||||
{
|
||||
vec_float4 s, c, angle;
|
||||
angle = spu_mul( radians, spu_splats(0.5f) );
|
||||
sincosf4( angle, &s, &c );
|
||||
vmathSoaQMakeFromElems( result, spu_splats(0.0f), s, spu_splats(0.0f), c );
|
||||
}
|
||||
|
||||
static inline void vmathSoaQMakeRotationZ( VmathSoaQuat *result, vec_float4 radians )
|
||||
{
|
||||
vec_float4 s, c, angle;
|
||||
angle = spu_mul( radians, spu_splats(0.5f) );
|
||||
sincosf4( angle, &s, &c );
|
||||
vmathSoaQMakeFromElems( result, spu_splats(0.0f), spu_splats(0.0f), s, c );
|
||||
}
|
||||
|
||||
static inline void vmathSoaQMul( VmathSoaQuat *result, const VmathSoaQuat *quat0, const VmathSoaQuat *quat1 )
|
||||
{
|
||||
vec_float4 tmpX, tmpY, tmpZ, tmpW;
|
||||
tmpX = spu_sub( spu_add( spu_add( spu_mul( quat0->w, quat1->x ), spu_mul( quat0->x, quat1->w ) ), spu_mul( quat0->y, quat1->z ) ), spu_mul( quat0->z, quat1->y ) );
|
||||
tmpY = spu_sub( spu_add( spu_add( spu_mul( quat0->w, quat1->y ), spu_mul( quat0->y, quat1->w ) ), spu_mul( quat0->z, quat1->x ) ), spu_mul( quat0->x, quat1->z ) );
|
||||
tmpZ = spu_sub( spu_add( spu_add( spu_mul( quat0->w, quat1->z ), spu_mul( quat0->z, quat1->w ) ), spu_mul( quat0->x, quat1->y ) ), spu_mul( quat0->y, quat1->x ) );
|
||||
tmpW = spu_sub( spu_sub( spu_sub( spu_mul( quat0->w, quat1->w ), spu_mul( quat0->x, quat1->x ) ), spu_mul( quat0->y, quat1->y ) ), spu_mul( quat0->z, quat1->z ) );
|
||||
vmathSoaQMakeFromElems( result, tmpX, tmpY, tmpZ, tmpW );
|
||||
}
|
||||
|
||||
static inline void vmathSoaQRotate( VmathSoaVector3 *result, const VmathSoaQuat *quat, const VmathSoaVector3 *vec )
|
||||
{
|
||||
vec_float4 tmpX, tmpY, tmpZ, tmpW;
|
||||
tmpX = spu_sub( spu_add( spu_mul( quat->w, vec->x ), spu_mul( quat->y, vec->z ) ), spu_mul( quat->z, vec->y ) );
|
||||
tmpY = spu_sub( spu_add( spu_mul( quat->w, vec->y ), spu_mul( quat->z, vec->x ) ), spu_mul( quat->x, vec->z ) );
|
||||
tmpZ = spu_sub( spu_add( spu_mul( quat->w, vec->z ), spu_mul( quat->x, vec->y ) ), spu_mul( quat->y, vec->x ) );
|
||||
tmpW = spu_add( spu_add( spu_mul( quat->x, vec->x ), spu_mul( quat->y, vec->y ) ), spu_mul( quat->z, vec->z ) );
|
||||
result->x = spu_add( spu_sub( spu_add( spu_mul( tmpW, quat->x ), spu_mul( tmpX, quat->w ) ), spu_mul( tmpY, quat->z ) ), spu_mul( tmpZ, quat->y ) );
|
||||
result->y = spu_add( spu_sub( spu_add( spu_mul( tmpW, quat->y ), spu_mul( tmpY, quat->w ) ), spu_mul( tmpZ, quat->x ) ), spu_mul( tmpX, quat->z ) );
|
||||
result->z = spu_add( spu_sub( spu_add( spu_mul( tmpW, quat->z ), spu_mul( tmpZ, quat->w ) ), spu_mul( tmpX, quat->y ) ), spu_mul( tmpY, quat->x ) );
|
||||
}
|
||||
|
||||
static inline void vmathSoaQConj( VmathSoaQuat *result, const VmathSoaQuat *quat )
|
||||
{
|
||||
vmathSoaQMakeFromElems( result, negatef4( quat->x ), negatef4( quat->y ), negatef4( quat->z ), quat->w );
|
||||
}
|
||||
|
||||
static inline void vmathSoaQSelect( VmathSoaQuat *result, const VmathSoaQuat *quat0, const VmathSoaQuat *quat1, vec_uint4 select1 )
|
||||
{
|
||||
result->x = spu_sel( quat0->x, quat1->x, select1 );
|
||||
result->y = spu_sel( quat0->y, quat1->y, select1 );
|
||||
result->z = spu_sel( quat0->z, quat1->z, select1 );
|
||||
result->w = spu_sel( quat0->w, quat1->w, select1 );
|
||||
}
|
||||
|
||||
#ifdef _VECTORMATH_DEBUG
|
||||
|
||||
static inline void vmathSoaQPrint( const VmathSoaQuat *quat )
|
||||
{
|
||||
VmathQuat vec0, vec1, vec2, vec3;
|
||||
vmathSoaQGet4Aos( quat, &vec0, &vec1, &vec2, &vec3 );
|
||||
printf("slot 0:\n");
|
||||
vmathQPrint( &vec0 );
|
||||
printf("slot 1:\n");
|
||||
vmathQPrint( &vec1 );
|
||||
printf("slot 2:\n");
|
||||
vmathQPrint( &vec2 );
|
||||
printf("slot 3:\n");
|
||||
vmathQPrint( &vec3 );
|
||||
}
|
||||
|
||||
static inline void vmathSoaQPrints( const VmathSoaQuat *quat, const char *name )
|
||||
{
|
||||
VmathQuat vec0, vec1, vec2, vec3;
|
||||
printf( "%s:\n", name );
|
||||
vmathSoaQGet4Aos( quat, &vec0, &vec1, &vec2, &vec3 );
|
||||
printf("slot 0:\n");
|
||||
vmathQPrint( &vec0 );
|
||||
printf("slot 1:\n");
|
||||
vmathQPrint( &vec1 );
|
||||
printf("slot 2:\n");
|
||||
vmathQPrint( &vec2 );
|
||||
printf("slot 3:\n");
|
||||
vmathQPrint( &vec3 );
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#endif
|
||||
319
Extras/vectormathlibrary/include/vectormath/spu/c/quat_soa_v.h
Normal file
319
Extras/vectormathlibrary/include/vectormath/spu/c/quat_soa_v.h
Normal file
@@ -0,0 +1,319 @@
|
||||
/*
|
||||
Copyright (C) 2006, 2007 Sony Computer Entertainment Inc.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms,
|
||||
with or without modification, are permitted provided that the
|
||||
following conditions are met:
|
||||
* Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
* Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in the
|
||||
documentation and/or other materials provided with the distribution.
|
||||
* Neither the name of the Sony Computer Entertainment Inc nor the names
|
||||
of its contributors may be used to endorse or promote products derived
|
||||
from this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
||||
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#ifndef _VECTORMATH_QUAT_SOA_V_C_H
|
||||
#define _VECTORMATH_QUAT_SOA_V_C_H
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif /* __cplusplus */
|
||||
|
||||
/*-----------------------------------------------------------------------------
|
||||
* Definitions
|
||||
*/
|
||||
#ifndef _VECTORMATH_INTERNAL_FUNCTIONS
|
||||
#define _VECTORMATH_INTERNAL_FUNCTIONS
|
||||
|
||||
#endif
|
||||
|
||||
static inline VmathSoaQuat vmathSoaQMakeFromElems_V( vec_float4 _x, vec_float4 _y, vec_float4 _z, vec_float4 _w )
|
||||
{
|
||||
VmathSoaQuat result;
|
||||
vmathSoaQMakeFromElems(&result, _x, _y, _z, _w);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaQuat vmathSoaQMakeFromV3Scalar_V( VmathSoaVector3 xyz, vec_float4 _w )
|
||||
{
|
||||
VmathSoaQuat result;
|
||||
vmathSoaQMakeFromV3Scalar(&result, &xyz, _w);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaQuat vmathSoaQMakeFromV4_V( VmathSoaVector4 vec )
|
||||
{
|
||||
VmathSoaQuat result;
|
||||
vmathSoaQMakeFromV4(&result, &vec);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaQuat vmathSoaQMakeFromScalar_V( vec_float4 scalar )
|
||||
{
|
||||
VmathSoaQuat result;
|
||||
vmathSoaQMakeFromScalar(&result, scalar);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaQuat vmathSoaQMakeFromAos_V( VmathQuat quat )
|
||||
{
|
||||
VmathSoaQuat result;
|
||||
vmathSoaQMakeFromAos(&result, &quat);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaQuat vmathSoaQMakeFrom4Aos_V( VmathQuat quat0, VmathQuat quat1, VmathQuat quat2, VmathQuat quat3 )
|
||||
{
|
||||
VmathSoaQuat result;
|
||||
vmathSoaQMakeFrom4Aos(&result, &quat0, &quat1, &quat2, &quat3);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaQuat vmathSoaQMakeIdentity_V( )
|
||||
{
|
||||
VmathSoaQuat result;
|
||||
vmathSoaQMakeIdentity(&result);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaQuat vmathSoaQLerp_V( vec_float4 t, VmathSoaQuat quat0, VmathSoaQuat quat1 )
|
||||
{
|
||||
VmathSoaQuat result;
|
||||
vmathSoaQLerp(&result, t, &quat0, &quat1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaQuat vmathSoaQSlerp_V( vec_float4 t, VmathSoaQuat unitQuat0, VmathSoaQuat unitQuat1 )
|
||||
{
|
||||
VmathSoaQuat result;
|
||||
vmathSoaQSlerp(&result, t, &unitQuat0, &unitQuat1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaQuat vmathSoaQSquad_V( vec_float4 t, VmathSoaQuat unitQuat0, VmathSoaQuat unitQuat1, VmathSoaQuat unitQuat2, VmathSoaQuat unitQuat3 )
|
||||
{
|
||||
VmathSoaQuat result;
|
||||
vmathSoaQSquad(&result, t, &unitQuat0, &unitQuat1, &unitQuat2, &unitQuat3);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline void vmathSoaQGet4Aos_V( VmathSoaQuat quat, VmathQuat *result0, VmathQuat *result1, VmathQuat *result2, VmathQuat *result3 )
|
||||
{
|
||||
vmathSoaQGet4Aos(&quat, result0, result1, result2, result3);
|
||||
}
|
||||
|
||||
static inline void vmathSoaQSetXYZ_V( VmathSoaQuat *result, VmathSoaVector3 vec )
|
||||
{
|
||||
vmathSoaQSetXYZ(result, &vec);
|
||||
}
|
||||
|
||||
static inline VmathSoaVector3 vmathSoaQGetXYZ_V( VmathSoaQuat quat )
|
||||
{
|
||||
VmathSoaVector3 result;
|
||||
vmathSoaQGetXYZ(&result, &quat);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline void vmathSoaQSetX_V( VmathSoaQuat *result, vec_float4 _x )
|
||||
{
|
||||
vmathSoaQSetX(result, _x);
|
||||
}
|
||||
|
||||
static inline vec_float4 vmathSoaQGetX_V( VmathSoaQuat quat )
|
||||
{
|
||||
return vmathSoaQGetX(&quat);
|
||||
}
|
||||
|
||||
static inline void vmathSoaQSetY_V( VmathSoaQuat *result, vec_float4 _y )
|
||||
{
|
||||
vmathSoaQSetY(result, _y);
|
||||
}
|
||||
|
||||
static inline vec_float4 vmathSoaQGetY_V( VmathSoaQuat quat )
|
||||
{
|
||||
return vmathSoaQGetY(&quat);
|
||||
}
|
||||
|
||||
static inline void vmathSoaQSetZ_V( VmathSoaQuat *result, vec_float4 _z )
|
||||
{
|
||||
vmathSoaQSetZ(result, _z);
|
||||
}
|
||||
|
||||
static inline vec_float4 vmathSoaQGetZ_V( VmathSoaQuat quat )
|
||||
{
|
||||
return vmathSoaQGetZ(&quat);
|
||||
}
|
||||
|
||||
static inline void vmathSoaQSetW_V( VmathSoaQuat *result, vec_float4 _w )
|
||||
{
|
||||
vmathSoaQSetW(result, _w);
|
||||
}
|
||||
|
||||
static inline vec_float4 vmathSoaQGetW_V( VmathSoaQuat quat )
|
||||
{
|
||||
return vmathSoaQGetW(&quat);
|
||||
}
|
||||
|
||||
static inline void vmathSoaQSetElem_V( VmathSoaQuat *result, int idx, vec_float4 value )
|
||||
{
|
||||
vmathSoaQSetElem(result, idx, value);
|
||||
}
|
||||
|
||||
static inline vec_float4 vmathSoaQGetElem_V( VmathSoaQuat quat, int idx )
|
||||
{
|
||||
return vmathSoaQGetElem(&quat, idx);
|
||||
}
|
||||
|
||||
static inline VmathSoaQuat vmathSoaQAdd_V( VmathSoaQuat quat0, VmathSoaQuat quat1 )
|
||||
{
|
||||
VmathSoaQuat result;
|
||||
vmathSoaQAdd(&result, &quat0, &quat1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaQuat vmathSoaQSub_V( VmathSoaQuat quat0, VmathSoaQuat quat1 )
|
||||
{
|
||||
VmathSoaQuat result;
|
||||
vmathSoaQSub(&result, &quat0, &quat1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaQuat vmathSoaQScalarMul_V( VmathSoaQuat quat, vec_float4 scalar )
|
||||
{
|
||||
VmathSoaQuat result;
|
||||
vmathSoaQScalarMul(&result, &quat, scalar);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaQuat vmathSoaQScalarDiv_V( VmathSoaQuat quat, vec_float4 scalar )
|
||||
{
|
||||
VmathSoaQuat result;
|
||||
vmathSoaQScalarDiv(&result, &quat, scalar);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaQuat vmathSoaQNeg_V( VmathSoaQuat quat )
|
||||
{
|
||||
VmathSoaQuat result;
|
||||
vmathSoaQNeg(&result, &quat);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline vec_float4 vmathSoaQDot_V( VmathSoaQuat quat0, VmathSoaQuat quat1 )
|
||||
{
|
||||
return vmathSoaQDot(&quat0, &quat1);
|
||||
}
|
||||
|
||||
static inline vec_float4 vmathSoaQNorm_V( VmathSoaQuat quat )
|
||||
{
|
||||
return vmathSoaQNorm(&quat);
|
||||
}
|
||||
|
||||
static inline vec_float4 vmathSoaQLength_V( VmathSoaQuat quat )
|
||||
{
|
||||
return vmathSoaQLength(&quat);
|
||||
}
|
||||
|
||||
static inline VmathSoaQuat vmathSoaQNormalize_V( VmathSoaQuat quat )
|
||||
{
|
||||
VmathSoaQuat result;
|
||||
vmathSoaQNormalize(&result, &quat);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaQuat vmathSoaQMakeRotationArc_V( VmathSoaVector3 unitVec0, VmathSoaVector3 unitVec1 )
|
||||
{
|
||||
VmathSoaQuat result;
|
||||
vmathSoaQMakeRotationArc(&result, &unitVec0, &unitVec1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaQuat vmathSoaQMakeRotationAxis_V( vec_float4 radians, VmathSoaVector3 unitVec )
|
||||
{
|
||||
VmathSoaQuat result;
|
||||
vmathSoaQMakeRotationAxis(&result, radians, &unitVec);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaQuat vmathSoaQMakeRotationX_V( vec_float4 radians )
|
||||
{
|
||||
VmathSoaQuat result;
|
||||
vmathSoaQMakeRotationX(&result, radians);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaQuat vmathSoaQMakeRotationY_V( vec_float4 radians )
|
||||
{
|
||||
VmathSoaQuat result;
|
||||
vmathSoaQMakeRotationY(&result, radians);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaQuat vmathSoaQMakeRotationZ_V( vec_float4 radians )
|
||||
{
|
||||
VmathSoaQuat result;
|
||||
vmathSoaQMakeRotationZ(&result, radians);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaQuat vmathSoaQMul_V( VmathSoaQuat quat0, VmathSoaQuat quat1 )
|
||||
{
|
||||
VmathSoaQuat result;
|
||||
vmathSoaQMul(&result, &quat0, &quat1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaVector3 vmathSoaQRotate_V( VmathSoaQuat quat, VmathSoaVector3 vec )
|
||||
{
|
||||
VmathSoaVector3 result;
|
||||
vmathSoaQRotate(&result, &quat, &vec);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaQuat vmathSoaQConj_V( VmathSoaQuat quat )
|
||||
{
|
||||
VmathSoaQuat result;
|
||||
vmathSoaQConj(&result, &quat);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaQuat vmathSoaQSelect_V( VmathSoaQuat quat0, VmathSoaQuat quat1, vec_uint4 select1 )
|
||||
{
|
||||
VmathSoaQuat result;
|
||||
vmathSoaQSelect(&result, &quat0, &quat1, select1);
|
||||
return result;
|
||||
}
|
||||
|
||||
#ifdef _VECTORMATH_DEBUG
|
||||
|
||||
static inline void vmathSoaQPrint_V( VmathSoaQuat quat )
|
||||
{
|
||||
vmathSoaQPrint(&quat);
|
||||
}
|
||||
|
||||
static inline void vmathSoaQPrints_V( VmathSoaQuat quat, const char *name )
|
||||
{
|
||||
vmathSoaQPrints(&quat, name);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#endif
|
||||
1029
Extras/vectormathlibrary/include/vectormath/spu/c/vec_aos.h
Normal file
1029
Extras/vectormathlibrary/include/vectormath/spu/c/vec_aos.h
Normal file
File diff suppressed because it is too large
Load Diff
951
Extras/vectormathlibrary/include/vectormath/spu/c/vec_aos_v.h
Normal file
951
Extras/vectormathlibrary/include/vectormath/spu/c/vec_aos_v.h
Normal file
@@ -0,0 +1,951 @@
|
||||
/*
|
||||
Copyright (C) 2006, 2007 Sony Computer Entertainment Inc.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms,
|
||||
with or without modification, are permitted provided that the
|
||||
following conditions are met:
|
||||
* Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
* Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in the
|
||||
documentation and/or other materials provided with the distribution.
|
||||
* Neither the name of the Sony Computer Entertainment Inc nor the names
|
||||
of its contributors may be used to endorse or promote products derived
|
||||
from this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
||||
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#ifndef _VECTORMATH_VEC_AOS_V_C_H
|
||||
#define _VECTORMATH_VEC_AOS_V_C_H
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif /* __cplusplus */
|
||||
|
||||
/*-----------------------------------------------------------------------------
|
||||
* Constants
|
||||
* for shuffles, words are labeled [x,y,z,w] [a,b,c,d]
|
||||
*/
|
||||
#define _VECTORMATH_SHUF_X 0x00010203
|
||||
#define _VECTORMATH_SHUF_Y 0x04050607
|
||||
#define _VECTORMATH_SHUF_Z 0x08090a0b
|
||||
#define _VECTORMATH_SHUF_W 0x0c0d0e0f
|
||||
#define _VECTORMATH_SHUF_A 0x10111213
|
||||
#define _VECTORMATH_SHUF_B 0x14151617
|
||||
#define _VECTORMATH_SHUF_C 0x18191a1b
|
||||
#define _VECTORMATH_SHUF_D 0x1c1d1e1f
|
||||
#define _VECTORMATH_SHUF_0 0x80808080
|
||||
#define _VECTORMATH_SHUF_XYZA (vec_uchar16)(vec_uint4){ _VECTORMATH_SHUF_X, _VECTORMATH_SHUF_Y, _VECTORMATH_SHUF_Z, _VECTORMATH_SHUF_A }
|
||||
#define _VECTORMATH_SHUF_ZXYW (vec_uchar16)(vec_uint4){ _VECTORMATH_SHUF_Z, _VECTORMATH_SHUF_X, _VECTORMATH_SHUF_Y, _VECTORMATH_SHUF_W }
|
||||
#define _VECTORMATH_SHUF_YZXW (vec_uchar16)(vec_uint4){ _VECTORMATH_SHUF_Y, _VECTORMATH_SHUF_Z, _VECTORMATH_SHUF_X, _VECTORMATH_SHUF_W }
|
||||
#define _VECTORMATH_SHUF_WABC (vec_uchar16)(vec_uint4){ _VECTORMATH_SHUF_W, _VECTORMATH_SHUF_A, _VECTORMATH_SHUF_B, _VECTORMATH_SHUF_C }
|
||||
#define _VECTORMATH_SHUF_ZWAB (vec_uchar16)(vec_uint4){ _VECTORMATH_SHUF_Z, _VECTORMATH_SHUF_W, _VECTORMATH_SHUF_A, _VECTORMATH_SHUF_B }
|
||||
#define _VECTORMATH_SHUF_XYZA (vec_uchar16)(vec_uint4){ _VECTORMATH_SHUF_X, _VECTORMATH_SHUF_Y, _VECTORMATH_SHUF_Z, _VECTORMATH_SHUF_A }
|
||||
#define _VECTORMATH_SHUF_YZAB (vec_uchar16)(vec_uint4){ _VECTORMATH_SHUF_Y, _VECTORMATH_SHUF_Z, _VECTORMATH_SHUF_A, _VECTORMATH_SHUF_B }
|
||||
#define _VECTORMATH_SHUF_ZABC (vec_uchar16)(vec_uint4){ _VECTORMATH_SHUF_Z, _VECTORMATH_SHUF_A, _VECTORMATH_SHUF_B, _VECTORMATH_SHUF_C }
|
||||
#define _VECTORMATH_UNIT_1000 (vec_float4){ 1.0f, 0.0f, 0.0f, 0.0f }
|
||||
#define _VECTORMATH_UNIT_0100 (vec_float4){ 0.0f, 1.0f, 0.0f, 0.0f }
|
||||
#define _VECTORMATH_UNIT_0010 (vec_float4){ 0.0f, 0.0f, 1.0f, 0.0f }
|
||||
#define _VECTORMATH_UNIT_0001 (vec_float4){ 0.0f, 0.0f, 0.0f, 1.0f }
|
||||
#define _VECTORMATH_SLERP_TOL 0.999f
|
||||
|
||||
/*-----------------------------------------------------------------------------
|
||||
* Definitions
|
||||
*/
|
||||
#ifndef _VECTORMATH_INTERNAL_FUNCTIONS
|
||||
#define _VECTORMATH_INTERNAL_FUNCTIONS
|
||||
|
||||
#endif
|
||||
|
||||
static inline VmathVector3 vmathV3MakeFromElems_V( float _x, float _y, float _z )
|
||||
{
|
||||
VmathVector3 result;
|
||||
vmathV3MakeFromElems(&result, _x, _y, _z);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathVector3 vmathV3MakeFromP3_V( VmathPoint3 pnt )
|
||||
{
|
||||
VmathVector3 result;
|
||||
vmathV3MakeFromP3(&result, &pnt);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathVector3 vmathV3MakeFromScalar_V( float scalar )
|
||||
{
|
||||
VmathVector3 result;
|
||||
vmathV3MakeFromScalar(&result, scalar);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathVector3 vmathV3MakeFrom128_V( vec_float4 vf4 )
|
||||
{
|
||||
VmathVector3 result;
|
||||
vmathV3MakeFrom128(&result, vf4);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathVector3 vmathV3MakeXAxis_V( )
|
||||
{
|
||||
VmathVector3 result;
|
||||
vmathV3MakeXAxis(&result);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathVector3 vmathV3MakeYAxis_V( )
|
||||
{
|
||||
VmathVector3 result;
|
||||
vmathV3MakeYAxis(&result);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathVector3 vmathV3MakeZAxis_V( )
|
||||
{
|
||||
VmathVector3 result;
|
||||
vmathV3MakeZAxis(&result);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathVector3 vmathV3Lerp_V( float t, VmathVector3 vec0, VmathVector3 vec1 )
|
||||
{
|
||||
VmathVector3 result;
|
||||
vmathV3Lerp(&result, t, &vec0, &vec1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathVector3 vmathV3Slerp_V( float t, VmathVector3 unitVec0, VmathVector3 unitVec1 )
|
||||
{
|
||||
VmathVector3 result;
|
||||
vmathV3Slerp(&result, t, &unitVec0, &unitVec1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline vec_float4 vmathV3Get128_V( VmathVector3 vec )
|
||||
{
|
||||
return vmathV3Get128(&vec);
|
||||
}
|
||||
|
||||
static inline void vmathV3StoreXYZ_V( VmathVector3 vec, vec_float4 *quad )
|
||||
{
|
||||
vmathV3StoreXYZ(&vec, quad);
|
||||
}
|
||||
|
||||
static inline void vmathV3LoadXYZArray_V( VmathVector3 *vec0, VmathVector3 *vec1, VmathVector3 *vec2, VmathVector3 *vec3, const vec_float4 *threeQuads )
|
||||
{
|
||||
vmathV3LoadXYZArray(vec0, vec1, vec2, vec3, threeQuads);
|
||||
}
|
||||
|
||||
static inline void vmathV3StoreXYZArray_V( VmathVector3 vec0, VmathVector3 vec1, VmathVector3 vec2, VmathVector3 vec3, vec_float4 *threeQuads )
|
||||
{
|
||||
vmathV3StoreXYZArray(&vec0, &vec1, &vec2, &vec3, threeQuads);
|
||||
}
|
||||
|
||||
static inline void vmathV3StoreHalfFloats_V( VmathVector3 vec0, VmathVector3 vec1, VmathVector3 vec2, VmathVector3 vec3, VmathVector3 vec4, VmathVector3 vec5, VmathVector3 vec6, VmathVector3 vec7, vec_ushort8 *threeQuads )
|
||||
{
|
||||
vmathV3StoreHalfFloats(&vec0, &vec1, &vec2, &vec3, &vec4, &vec5, &vec6, &vec7, threeQuads);
|
||||
}
|
||||
|
||||
static inline void vmathV3SetX_V( VmathVector3 *result, float _x )
|
||||
{
|
||||
vmathV3SetX(result, _x);
|
||||
}
|
||||
|
||||
static inline float vmathV3GetX_V( VmathVector3 vec )
|
||||
{
|
||||
return vmathV3GetX(&vec);
|
||||
}
|
||||
|
||||
static inline void vmathV3SetY_V( VmathVector3 *result, float _y )
|
||||
{
|
||||
vmathV3SetY(result, _y);
|
||||
}
|
||||
|
||||
static inline float vmathV3GetY_V( VmathVector3 vec )
|
||||
{
|
||||
return vmathV3GetY(&vec);
|
||||
}
|
||||
|
||||
static inline void vmathV3SetZ_V( VmathVector3 *result, float _z )
|
||||
{
|
||||
vmathV3SetZ(result, _z);
|
||||
}
|
||||
|
||||
static inline float vmathV3GetZ_V( VmathVector3 vec )
|
||||
{
|
||||
return vmathV3GetZ(&vec);
|
||||
}
|
||||
|
||||
static inline void vmathV3SetElem_V( VmathVector3 *result, int idx, float value )
|
||||
{
|
||||
vmathV3SetElem(result, idx, value);
|
||||
}
|
||||
|
||||
static inline float vmathV3GetElem_V( VmathVector3 vec, int idx )
|
||||
{
|
||||
return vmathV3GetElem(&vec, idx);
|
||||
}
|
||||
|
||||
static inline VmathVector3 vmathV3Add_V( VmathVector3 vec0, VmathVector3 vec1 )
|
||||
{
|
||||
VmathVector3 result;
|
||||
vmathV3Add(&result, &vec0, &vec1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathVector3 vmathV3Sub_V( VmathVector3 vec0, VmathVector3 vec1 )
|
||||
{
|
||||
VmathVector3 result;
|
||||
vmathV3Sub(&result, &vec0, &vec1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathPoint3 vmathV3AddP3_V( VmathVector3 vec, VmathPoint3 pnt1 )
|
||||
{
|
||||
VmathPoint3 result;
|
||||
vmathV3AddP3(&result, &vec, &pnt1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathVector3 vmathV3ScalarMul_V( VmathVector3 vec, float scalar )
|
||||
{
|
||||
VmathVector3 result;
|
||||
vmathV3ScalarMul(&result, &vec, scalar);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathVector3 vmathV3ScalarDiv_V( VmathVector3 vec, float scalar )
|
||||
{
|
||||
VmathVector3 result;
|
||||
vmathV3ScalarDiv(&result, &vec, scalar);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathVector3 vmathV3Neg_V( VmathVector3 vec )
|
||||
{
|
||||
VmathVector3 result;
|
||||
vmathV3Neg(&result, &vec);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathVector3 vmathV3MulPerElem_V( VmathVector3 vec0, VmathVector3 vec1 )
|
||||
{
|
||||
VmathVector3 result;
|
||||
vmathV3MulPerElem(&result, &vec0, &vec1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathVector3 vmathV3DivPerElem_V( VmathVector3 vec0, VmathVector3 vec1 )
|
||||
{
|
||||
VmathVector3 result;
|
||||
vmathV3DivPerElem(&result, &vec0, &vec1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathVector3 vmathV3RecipPerElem_V( VmathVector3 vec )
|
||||
{
|
||||
VmathVector3 result;
|
||||
vmathV3RecipPerElem(&result, &vec);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathVector3 vmathV3SqrtPerElem_V( VmathVector3 vec )
|
||||
{
|
||||
VmathVector3 result;
|
||||
vmathV3SqrtPerElem(&result, &vec);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathVector3 vmathV3RsqrtPerElem_V( VmathVector3 vec )
|
||||
{
|
||||
VmathVector3 result;
|
||||
vmathV3RsqrtPerElem(&result, &vec);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathVector3 vmathV3AbsPerElem_V( VmathVector3 vec )
|
||||
{
|
||||
VmathVector3 result;
|
||||
vmathV3AbsPerElem(&result, &vec);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathVector3 vmathV3CopySignPerElem_V( VmathVector3 vec0, VmathVector3 vec1 )
|
||||
{
|
||||
VmathVector3 result;
|
||||
vmathV3CopySignPerElem(&result, &vec0, &vec1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathVector3 vmathV3MaxPerElem_V( VmathVector3 vec0, VmathVector3 vec1 )
|
||||
{
|
||||
VmathVector3 result;
|
||||
vmathV3MaxPerElem(&result, &vec0, &vec1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline float vmathV3MaxElem_V( VmathVector3 vec )
|
||||
{
|
||||
return vmathV3MaxElem(&vec);
|
||||
}
|
||||
|
||||
static inline VmathVector3 vmathV3MinPerElem_V( VmathVector3 vec0, VmathVector3 vec1 )
|
||||
{
|
||||
VmathVector3 result;
|
||||
vmathV3MinPerElem(&result, &vec0, &vec1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline float vmathV3MinElem_V( VmathVector3 vec )
|
||||
{
|
||||
return vmathV3MinElem(&vec);
|
||||
}
|
||||
|
||||
static inline float vmathV3Sum_V( VmathVector3 vec )
|
||||
{
|
||||
return vmathV3Sum(&vec);
|
||||
}
|
||||
|
||||
static inline float vmathV3Dot_V( VmathVector3 vec0, VmathVector3 vec1 )
|
||||
{
|
||||
return vmathV3Dot(&vec0, &vec1);
|
||||
}
|
||||
|
||||
static inline float vmathV3LengthSqr_V( VmathVector3 vec )
|
||||
{
|
||||
return vmathV3LengthSqr(&vec);
|
||||
}
|
||||
|
||||
static inline float vmathV3Length_V( VmathVector3 vec )
|
||||
{
|
||||
return vmathV3Length(&vec);
|
||||
}
|
||||
|
||||
static inline VmathVector3 vmathV3Normalize_V( VmathVector3 vec )
|
||||
{
|
||||
VmathVector3 result;
|
||||
vmathV3Normalize(&result, &vec);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathVector3 vmathV3Cross_V( VmathVector3 vec0, VmathVector3 vec1 )
|
||||
{
|
||||
VmathVector3 result;
|
||||
vmathV3Cross(&result, &vec0, &vec1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathVector3 vmathV3Select_V( VmathVector3 vec0, VmathVector3 vec1, unsigned int select1 )
|
||||
{
|
||||
VmathVector3 result;
|
||||
vmathV3Select(&result, &vec0, &vec1, select1);
|
||||
return result;
|
||||
}
|
||||
|
||||
#ifdef _VECTORMATH_DEBUG
|
||||
|
||||
static inline void vmathV3Print_V( VmathVector3 vec )
|
||||
{
|
||||
vmathV3Print(&vec);
|
||||
}
|
||||
|
||||
static inline void vmathV3Prints_V( VmathVector3 vec, const char *name )
|
||||
{
|
||||
vmathV3Prints(&vec, name);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
static inline VmathVector4 vmathV4MakeFromElems_V( float _x, float _y, float _z, float _w )
|
||||
{
|
||||
VmathVector4 result;
|
||||
vmathV4MakeFromElems(&result, _x, _y, _z, _w);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathVector4 vmathV4MakeFromV3Scalar_V( VmathVector3 xyz, float _w )
|
||||
{
|
||||
VmathVector4 result;
|
||||
vmathV4MakeFromV3Scalar(&result, &xyz, _w);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathVector4 vmathV4MakeFromV3_V( VmathVector3 vec )
|
||||
{
|
||||
VmathVector4 result;
|
||||
vmathV4MakeFromV3(&result, &vec);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathVector4 vmathV4MakeFromP3_V( VmathPoint3 pnt )
|
||||
{
|
||||
VmathVector4 result;
|
||||
vmathV4MakeFromP3(&result, &pnt);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathVector4 vmathV4MakeFromQ_V( VmathQuat quat )
|
||||
{
|
||||
VmathVector4 result;
|
||||
vmathV4MakeFromQ(&result, &quat);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathVector4 vmathV4MakeFromScalar_V( float scalar )
|
||||
{
|
||||
VmathVector4 result;
|
||||
vmathV4MakeFromScalar(&result, scalar);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathVector4 vmathV4MakeFrom128_V( vec_float4 vf4 )
|
||||
{
|
||||
VmathVector4 result;
|
||||
vmathV4MakeFrom128(&result, vf4);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathVector4 vmathV4MakeXAxis_V( )
|
||||
{
|
||||
VmathVector4 result;
|
||||
vmathV4MakeXAxis(&result);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathVector4 vmathV4MakeYAxis_V( )
|
||||
{
|
||||
VmathVector4 result;
|
||||
vmathV4MakeYAxis(&result);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathVector4 vmathV4MakeZAxis_V( )
|
||||
{
|
||||
VmathVector4 result;
|
||||
vmathV4MakeZAxis(&result);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathVector4 vmathV4MakeWAxis_V( )
|
||||
{
|
||||
VmathVector4 result;
|
||||
vmathV4MakeWAxis(&result);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathVector4 vmathV4Lerp_V( float t, VmathVector4 vec0, VmathVector4 vec1 )
|
||||
{
|
||||
VmathVector4 result;
|
||||
vmathV4Lerp(&result, t, &vec0, &vec1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathVector4 vmathV4Slerp_V( float t, VmathVector4 unitVec0, VmathVector4 unitVec1 )
|
||||
{
|
||||
VmathVector4 result;
|
||||
vmathV4Slerp(&result, t, &unitVec0, &unitVec1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline vec_float4 vmathV4Get128_V( VmathVector4 vec )
|
||||
{
|
||||
return vmathV4Get128(&vec);
|
||||
}
|
||||
|
||||
static inline void vmathV4StoreHalfFloats_V( VmathVector4 vec0, VmathVector4 vec1, VmathVector4 vec2, VmathVector4 vec3, vec_ushort8 *twoQuads )
|
||||
{
|
||||
vmathV4StoreHalfFloats(&vec0, &vec1, &vec2, &vec3, twoQuads);
|
||||
}
|
||||
|
||||
static inline void vmathV4SetXYZ_V( VmathVector4 *result, VmathVector3 vec )
|
||||
{
|
||||
vmathV4SetXYZ(result, &vec);
|
||||
}
|
||||
|
||||
static inline VmathVector3 vmathV4GetXYZ_V( VmathVector4 vec )
|
||||
{
|
||||
VmathVector3 result;
|
||||
vmathV4GetXYZ(&result, &vec);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline void vmathV4SetX_V( VmathVector4 *result, float _x )
|
||||
{
|
||||
vmathV4SetX(result, _x);
|
||||
}
|
||||
|
||||
static inline float vmathV4GetX_V( VmathVector4 vec )
|
||||
{
|
||||
return vmathV4GetX(&vec);
|
||||
}
|
||||
|
||||
static inline void vmathV4SetY_V( VmathVector4 *result, float _y )
|
||||
{
|
||||
vmathV4SetY(result, _y);
|
||||
}
|
||||
|
||||
static inline float vmathV4GetY_V( VmathVector4 vec )
|
||||
{
|
||||
return vmathV4GetY(&vec);
|
||||
}
|
||||
|
||||
static inline void vmathV4SetZ_V( VmathVector4 *result, float _z )
|
||||
{
|
||||
vmathV4SetZ(result, _z);
|
||||
}
|
||||
|
||||
static inline float vmathV4GetZ_V( VmathVector4 vec )
|
||||
{
|
||||
return vmathV4GetZ(&vec);
|
||||
}
|
||||
|
||||
static inline void vmathV4SetW_V( VmathVector4 *result, float _w )
|
||||
{
|
||||
vmathV4SetW(result, _w);
|
||||
}
|
||||
|
||||
static inline float vmathV4GetW_V( VmathVector4 vec )
|
||||
{
|
||||
return vmathV4GetW(&vec);
|
||||
}
|
||||
|
||||
static inline void vmathV4SetElem_V( VmathVector4 *result, int idx, float value )
|
||||
{
|
||||
vmathV4SetElem(result, idx, value);
|
||||
}
|
||||
|
||||
static inline float vmathV4GetElem_V( VmathVector4 vec, int idx )
|
||||
{
|
||||
return vmathV4GetElem(&vec, idx);
|
||||
}
|
||||
|
||||
static inline VmathVector4 vmathV4Add_V( VmathVector4 vec0, VmathVector4 vec1 )
|
||||
{
|
||||
VmathVector4 result;
|
||||
vmathV4Add(&result, &vec0, &vec1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathVector4 vmathV4Sub_V( VmathVector4 vec0, VmathVector4 vec1 )
|
||||
{
|
||||
VmathVector4 result;
|
||||
vmathV4Sub(&result, &vec0, &vec1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathVector4 vmathV4ScalarMul_V( VmathVector4 vec, float scalar )
|
||||
{
|
||||
VmathVector4 result;
|
||||
vmathV4ScalarMul(&result, &vec, scalar);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathVector4 vmathV4ScalarDiv_V( VmathVector4 vec, float scalar )
|
||||
{
|
||||
VmathVector4 result;
|
||||
vmathV4ScalarDiv(&result, &vec, scalar);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathVector4 vmathV4Neg_V( VmathVector4 vec )
|
||||
{
|
||||
VmathVector4 result;
|
||||
vmathV4Neg(&result, &vec);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathVector4 vmathV4MulPerElem_V( VmathVector4 vec0, VmathVector4 vec1 )
|
||||
{
|
||||
VmathVector4 result;
|
||||
vmathV4MulPerElem(&result, &vec0, &vec1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathVector4 vmathV4DivPerElem_V( VmathVector4 vec0, VmathVector4 vec1 )
|
||||
{
|
||||
VmathVector4 result;
|
||||
vmathV4DivPerElem(&result, &vec0, &vec1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathVector4 vmathV4RecipPerElem_V( VmathVector4 vec )
|
||||
{
|
||||
VmathVector4 result;
|
||||
vmathV4RecipPerElem(&result, &vec);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathVector4 vmathV4SqrtPerElem_V( VmathVector4 vec )
|
||||
{
|
||||
VmathVector4 result;
|
||||
vmathV4SqrtPerElem(&result, &vec);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathVector4 vmathV4RsqrtPerElem_V( VmathVector4 vec )
|
||||
{
|
||||
VmathVector4 result;
|
||||
vmathV4RsqrtPerElem(&result, &vec);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathVector4 vmathV4AbsPerElem_V( VmathVector4 vec )
|
||||
{
|
||||
VmathVector4 result;
|
||||
vmathV4AbsPerElem(&result, &vec);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathVector4 vmathV4CopySignPerElem_V( VmathVector4 vec0, VmathVector4 vec1 )
|
||||
{
|
||||
VmathVector4 result;
|
||||
vmathV4CopySignPerElem(&result, &vec0, &vec1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathVector4 vmathV4MaxPerElem_V( VmathVector4 vec0, VmathVector4 vec1 )
|
||||
{
|
||||
VmathVector4 result;
|
||||
vmathV4MaxPerElem(&result, &vec0, &vec1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline float vmathV4MaxElem_V( VmathVector4 vec )
|
||||
{
|
||||
return vmathV4MaxElem(&vec);
|
||||
}
|
||||
|
||||
static inline VmathVector4 vmathV4MinPerElem_V( VmathVector4 vec0, VmathVector4 vec1 )
|
||||
{
|
||||
VmathVector4 result;
|
||||
vmathV4MinPerElem(&result, &vec0, &vec1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline float vmathV4MinElem_V( VmathVector4 vec )
|
||||
{
|
||||
return vmathV4MinElem(&vec);
|
||||
}
|
||||
|
||||
static inline float vmathV4Sum_V( VmathVector4 vec )
|
||||
{
|
||||
return vmathV4Sum(&vec);
|
||||
}
|
||||
|
||||
static inline float vmathV4Dot_V( VmathVector4 vec0, VmathVector4 vec1 )
|
||||
{
|
||||
return vmathV4Dot(&vec0, &vec1);
|
||||
}
|
||||
|
||||
static inline float vmathV4LengthSqr_V( VmathVector4 vec )
|
||||
{
|
||||
return vmathV4LengthSqr(&vec);
|
||||
}
|
||||
|
||||
static inline float vmathV4Length_V( VmathVector4 vec )
|
||||
{
|
||||
return vmathV4Length(&vec);
|
||||
}
|
||||
|
||||
static inline VmathVector4 vmathV4Normalize_V( VmathVector4 vec )
|
||||
{
|
||||
VmathVector4 result;
|
||||
vmathV4Normalize(&result, &vec);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathVector4 vmathV4Select_V( VmathVector4 vec0, VmathVector4 vec1, unsigned int select1 )
|
||||
{
|
||||
VmathVector4 result;
|
||||
vmathV4Select(&result, &vec0, &vec1, select1);
|
||||
return result;
|
||||
}
|
||||
|
||||
#ifdef _VECTORMATH_DEBUG
|
||||
|
||||
static inline void vmathV4Print_V( VmathVector4 vec )
|
||||
{
|
||||
vmathV4Print(&vec);
|
||||
}
|
||||
|
||||
static inline void vmathV4Prints_V( VmathVector4 vec, const char *name )
|
||||
{
|
||||
vmathV4Prints(&vec, name);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
static inline VmathPoint3 vmathP3MakeFromElems_V( float _x, float _y, float _z )
|
||||
{
|
||||
VmathPoint3 result;
|
||||
vmathP3MakeFromElems(&result, _x, _y, _z);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathPoint3 vmathP3MakeFromV3_V( VmathVector3 vec )
|
||||
{
|
||||
VmathPoint3 result;
|
||||
vmathP3MakeFromV3(&result, &vec);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathPoint3 vmathP3MakeFromScalar_V( float scalar )
|
||||
{
|
||||
VmathPoint3 result;
|
||||
vmathP3MakeFromScalar(&result, scalar);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathPoint3 vmathP3MakeFrom128_V( vec_float4 vf4 )
|
||||
{
|
||||
VmathPoint3 result;
|
||||
vmathP3MakeFrom128(&result, vf4);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathPoint3 vmathP3Lerp_V( float t, VmathPoint3 pnt0, VmathPoint3 pnt1 )
|
||||
{
|
||||
VmathPoint3 result;
|
||||
vmathP3Lerp(&result, t, &pnt0, &pnt1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline vec_float4 vmathP3Get128_V( VmathPoint3 pnt )
|
||||
{
|
||||
return vmathP3Get128(&pnt);
|
||||
}
|
||||
|
||||
static inline void vmathP3StoreXYZ_V( VmathPoint3 pnt, vec_float4 *quad )
|
||||
{
|
||||
vmathP3StoreXYZ(&pnt, quad);
|
||||
}
|
||||
|
||||
static inline void vmathP3LoadXYZArray_V( VmathPoint3 *pnt0, VmathPoint3 *pnt1, VmathPoint3 *pnt2, VmathPoint3 *pnt3, const vec_float4 *threeQuads )
|
||||
{
|
||||
vmathP3LoadXYZArray(pnt0, pnt1, pnt2, pnt3, threeQuads);
|
||||
}
|
||||
|
||||
static inline void vmathP3StoreXYZArray_V( VmathPoint3 pnt0, VmathPoint3 pnt1, VmathPoint3 pnt2, VmathPoint3 pnt3, vec_float4 *threeQuads )
|
||||
{
|
||||
vmathP3StoreXYZArray(&pnt0, &pnt1, &pnt2, &pnt3, threeQuads);
|
||||
}
|
||||
|
||||
static inline void vmathP3StoreHalfFloats_V( VmathPoint3 pnt0, VmathPoint3 pnt1, VmathPoint3 pnt2, VmathPoint3 pnt3, VmathPoint3 pnt4, VmathPoint3 pnt5, VmathPoint3 pnt6, VmathPoint3 pnt7, vec_ushort8 *threeQuads )
|
||||
{
|
||||
vmathP3StoreHalfFloats(&pnt0, &pnt1, &pnt2, &pnt3, &pnt4, &pnt5, &pnt6, &pnt7, threeQuads);
|
||||
}
|
||||
|
||||
static inline void vmathP3SetX_V( VmathPoint3 *result, float _x )
|
||||
{
|
||||
vmathP3SetX(result, _x);
|
||||
}
|
||||
|
||||
static inline float vmathP3GetX_V( VmathPoint3 pnt )
|
||||
{
|
||||
return vmathP3GetX(&pnt);
|
||||
}
|
||||
|
||||
static inline void vmathP3SetY_V( VmathPoint3 *result, float _y )
|
||||
{
|
||||
vmathP3SetY(result, _y);
|
||||
}
|
||||
|
||||
static inline float vmathP3GetY_V( VmathPoint3 pnt )
|
||||
{
|
||||
return vmathP3GetY(&pnt);
|
||||
}
|
||||
|
||||
static inline void vmathP3SetZ_V( VmathPoint3 *result, float _z )
|
||||
{
|
||||
vmathP3SetZ(result, _z);
|
||||
}
|
||||
|
||||
static inline float vmathP3GetZ_V( VmathPoint3 pnt )
|
||||
{
|
||||
return vmathP3GetZ(&pnt);
|
||||
}
|
||||
|
||||
static inline void vmathP3SetElem_V( VmathPoint3 *result, int idx, float value )
|
||||
{
|
||||
vmathP3SetElem(result, idx, value);
|
||||
}
|
||||
|
||||
static inline float vmathP3GetElem_V( VmathPoint3 pnt, int idx )
|
||||
{
|
||||
return vmathP3GetElem(&pnt, idx);
|
||||
}
|
||||
|
||||
static inline VmathVector3 vmathP3Sub_V( VmathPoint3 pnt0, VmathPoint3 pnt1 )
|
||||
{
|
||||
VmathVector3 result;
|
||||
vmathP3Sub(&result, &pnt0, &pnt1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathPoint3 vmathP3AddV3_V( VmathPoint3 pnt, VmathVector3 vec1 )
|
||||
{
|
||||
VmathPoint3 result;
|
||||
vmathP3AddV3(&result, &pnt, &vec1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathPoint3 vmathP3SubV3_V( VmathPoint3 pnt, VmathVector3 vec1 )
|
||||
{
|
||||
VmathPoint3 result;
|
||||
vmathP3SubV3(&result, &pnt, &vec1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathPoint3 vmathP3MulPerElem_V( VmathPoint3 pnt0, VmathPoint3 pnt1 )
|
||||
{
|
||||
VmathPoint3 result;
|
||||
vmathP3MulPerElem(&result, &pnt0, &pnt1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathPoint3 vmathP3DivPerElem_V( VmathPoint3 pnt0, VmathPoint3 pnt1 )
|
||||
{
|
||||
VmathPoint3 result;
|
||||
vmathP3DivPerElem(&result, &pnt0, &pnt1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathPoint3 vmathP3RecipPerElem_V( VmathPoint3 pnt )
|
||||
{
|
||||
VmathPoint3 result;
|
||||
vmathP3RecipPerElem(&result, &pnt);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathPoint3 vmathP3SqrtPerElem_V( VmathPoint3 pnt )
|
||||
{
|
||||
VmathPoint3 result;
|
||||
vmathP3SqrtPerElem(&result, &pnt);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathPoint3 vmathP3RsqrtPerElem_V( VmathPoint3 pnt )
|
||||
{
|
||||
VmathPoint3 result;
|
||||
vmathP3RsqrtPerElem(&result, &pnt);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathPoint3 vmathP3AbsPerElem_V( VmathPoint3 pnt )
|
||||
{
|
||||
VmathPoint3 result;
|
||||
vmathP3AbsPerElem(&result, &pnt);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathPoint3 vmathP3CopySignPerElem_V( VmathPoint3 pnt0, VmathPoint3 pnt1 )
|
||||
{
|
||||
VmathPoint3 result;
|
||||
vmathP3CopySignPerElem(&result, &pnt0, &pnt1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathPoint3 vmathP3MaxPerElem_V( VmathPoint3 pnt0, VmathPoint3 pnt1 )
|
||||
{
|
||||
VmathPoint3 result;
|
||||
vmathP3MaxPerElem(&result, &pnt0, &pnt1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline float vmathP3MaxElem_V( VmathPoint3 pnt )
|
||||
{
|
||||
return vmathP3MaxElem(&pnt);
|
||||
}
|
||||
|
||||
static inline VmathPoint3 vmathP3MinPerElem_V( VmathPoint3 pnt0, VmathPoint3 pnt1 )
|
||||
{
|
||||
VmathPoint3 result;
|
||||
vmathP3MinPerElem(&result, &pnt0, &pnt1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline float vmathP3MinElem_V( VmathPoint3 pnt )
|
||||
{
|
||||
return vmathP3MinElem(&pnt);
|
||||
}
|
||||
|
||||
static inline float vmathP3Sum_V( VmathPoint3 pnt )
|
||||
{
|
||||
return vmathP3Sum(&pnt);
|
||||
}
|
||||
|
||||
static inline VmathPoint3 vmathP3Scale_V( VmathPoint3 pnt, float scaleVal )
|
||||
{
|
||||
VmathPoint3 result;
|
||||
vmathP3Scale(&result, &pnt, scaleVal);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathPoint3 vmathP3NonUniformScale_V( VmathPoint3 pnt, VmathVector3 scaleVec )
|
||||
{
|
||||
VmathPoint3 result;
|
||||
vmathP3NonUniformScale(&result, &pnt, &scaleVec);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline float vmathP3Projection_V( VmathPoint3 pnt, VmathVector3 unitVec )
|
||||
{
|
||||
return vmathP3Projection(&pnt, &unitVec);
|
||||
}
|
||||
|
||||
static inline float vmathP3DistSqrFromOrigin_V( VmathPoint3 pnt )
|
||||
{
|
||||
return vmathP3DistSqrFromOrigin(&pnt);
|
||||
}
|
||||
|
||||
static inline float vmathP3DistFromOrigin_V( VmathPoint3 pnt )
|
||||
{
|
||||
return vmathP3DistFromOrigin(&pnt);
|
||||
}
|
||||
|
||||
static inline float vmathP3DistSqr_V( VmathPoint3 pnt0, VmathPoint3 pnt1 )
|
||||
{
|
||||
return vmathP3DistSqr(&pnt0, &pnt1);
|
||||
}
|
||||
|
||||
static inline float vmathP3Dist_V( VmathPoint3 pnt0, VmathPoint3 pnt1 )
|
||||
{
|
||||
return vmathP3Dist(&pnt0, &pnt1);
|
||||
}
|
||||
|
||||
static inline VmathPoint3 vmathP3Select_V( VmathPoint3 pnt0, VmathPoint3 pnt1, unsigned int select1 )
|
||||
{
|
||||
VmathPoint3 result;
|
||||
vmathP3Select(&result, &pnt0, &pnt1, select1);
|
||||
return result;
|
||||
}
|
||||
|
||||
#ifdef _VECTORMATH_DEBUG
|
||||
|
||||
static inline void vmathP3Print_V( VmathPoint3 pnt )
|
||||
{
|
||||
vmathP3Print(&pnt);
|
||||
}
|
||||
|
||||
static inline void vmathP3Prints_V( VmathPoint3 pnt, const char *name )
|
||||
{
|
||||
vmathP3Prints(&pnt, name);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#endif
|
||||
1237
Extras/vectormathlibrary/include/vectormath/spu/c/vec_soa.h
Normal file
1237
Extras/vectormathlibrary/include/vectormath/spu/c/vec_soa.h
Normal file
File diff suppressed because it is too large
Load Diff
962
Extras/vectormathlibrary/include/vectormath/spu/c/vec_soa_v.h
Normal file
962
Extras/vectormathlibrary/include/vectormath/spu/c/vec_soa_v.h
Normal file
@@ -0,0 +1,962 @@
|
||||
/*
|
||||
Copyright (C) 2006, 2007 Sony Computer Entertainment Inc.
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms,
|
||||
with or without modification, are permitted provided that the
|
||||
following conditions are met:
|
||||
* Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
* Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in the
|
||||
documentation and/or other materials provided with the distribution.
|
||||
* Neither the name of the Sony Computer Entertainment Inc nor the names
|
||||
of its contributors may be used to endorse or promote products derived
|
||||
from this software without specific prior written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
||||
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#ifndef _VECTORMATH_VEC_SOA_V_C_H
|
||||
#define _VECTORMATH_VEC_SOA_V_C_H
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif /* __cplusplus */
|
||||
|
||||
/*-----------------------------------------------------------------------------
|
||||
* Constants
|
||||
* for shuffles, words are labeled [x,y,z,w] [a,b,c,d]
|
||||
*/
|
||||
#define _VECTORMATH_SHUF_X 0x00010203
|
||||
#define _VECTORMATH_SHUF_Y 0x04050607
|
||||
#define _VECTORMATH_SHUF_Z 0x08090a0b
|
||||
#define _VECTORMATH_SHUF_W 0x0c0d0e0f
|
||||
#define _VECTORMATH_SHUF_A 0x10111213
|
||||
#define _VECTORMATH_SHUF_B 0x14151617
|
||||
#define _VECTORMATH_SHUF_C 0x18191a1b
|
||||
#define _VECTORMATH_SHUF_D 0x1c1d1e1f
|
||||
#define _VECTORMATH_SHUF_0 0x80808080
|
||||
#define _VECTORMATH_SHUF_XAYB ((vec_uchar16)(vec_uint4){ _VECTORMATH_SHUF_X, _VECTORMATH_SHUF_A, _VECTORMATH_SHUF_Y, _VECTORMATH_SHUF_B })
|
||||
#define _VECTORMATH_SHUF_ZCWD ((vec_uchar16)(vec_uint4){ _VECTORMATH_SHUF_Z, _VECTORMATH_SHUF_C, _VECTORMATH_SHUF_W, _VECTORMATH_SHUF_D })
|
||||
#define _VECTORMATH_SHUF_ZBW0 ((vec_uchar16)(vec_uint4){ _VECTORMATH_SHUF_Z, _VECTORMATH_SHUF_B, _VECTORMATH_SHUF_W, _VECTORMATH_SHUF_0 })
|
||||
#define _VECTORMATH_SHUF_XCY0 ((vec_uchar16)(vec_uint4){ _VECTORMATH_SHUF_X, _VECTORMATH_SHUF_C, _VECTORMATH_SHUF_Y, _VECTORMATH_SHUF_0 })
|
||||
#define _VECTORMATH_SHUF_ZDW0 ((vec_uchar16)(vec_uint4){ _VECTORMATH_SHUF_Z, _VECTORMATH_SHUF_D, _VECTORMATH_SHUF_W, _VECTORMATH_SHUF_0 })
|
||||
#define _VECTORMATH_SHUF_XAZC ((vec_uchar16)(vec_uint4){ _VECTORMATH_SHUF_X, _VECTORMATH_SHUF_A, _VECTORMATH_SHUF_Z, _VECTORMATH_SHUF_C })
|
||||
#define _VECTORMATH_SHUF_ZDXB ((vec_uchar16)(vec_uint4){ _VECTORMATH_SHUF_Z, _VECTORMATH_SHUF_D, _VECTORMATH_SHUF_X, _VECTORMATH_SHUF_B })
|
||||
#define _VECTORMATH_SHUF_YBWD ((vec_uchar16)(vec_uint4){ _VECTORMATH_SHUF_Y, _VECTORMATH_SHUF_B, _VECTORMATH_SHUF_W, _VECTORMATH_SHUF_D })
|
||||
#define _VECTORMATH_SHUF_XDZB ((vec_uchar16)(vec_uint4){ _VECTORMATH_SHUF_X, _VECTORMATH_SHUF_D, _VECTORMATH_SHUF_Z, _VECTORMATH_SHUF_B })
|
||||
#define _VECTORMATH_SHUF_YAWC ((vec_uchar16)(vec_uint4){ _VECTORMATH_SHUF_Y, _VECTORMATH_SHUF_A, _VECTORMATH_SHUF_W, _VECTORMATH_SHUF_C })
|
||||
#define _VECTORMATH_SHUF_ZBXD ((vec_uchar16)(vec_uint4){ _VECTORMATH_SHUF_Z, _VECTORMATH_SHUF_B, _VECTORMATH_SHUF_X, _VECTORMATH_SHUF_D })
|
||||
#define _VECTORMATH_SHUF_XYCD ((vec_uchar16)(vec_uint4){ _VECTORMATH_SHUF_X, _VECTORMATH_SHUF_Y, _VECTORMATH_SHUF_C, _VECTORMATH_SHUF_D })
|
||||
#define _VECTORMATH_SLERP_TOL 0.999f
|
||||
|
||||
/*-----------------------------------------------------------------------------
|
||||
* Definitions
|
||||
*/
|
||||
#ifndef _VECTORMATH_INTERNAL_FUNCTIONS
|
||||
#define _VECTORMATH_INTERNAL_FUNCTIONS
|
||||
|
||||
#endif
|
||||
|
||||
static inline VmathSoaVector3 vmathSoaV3MakeFromElems_V( vec_float4 _x, vec_float4 _y, vec_float4 _z )
|
||||
{
|
||||
VmathSoaVector3 result;
|
||||
vmathSoaV3MakeFromElems(&result, _x, _y, _z);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaVector3 vmathSoaV3MakeFromP3_V( VmathSoaPoint3 pnt )
|
||||
{
|
||||
VmathSoaVector3 result;
|
||||
vmathSoaV3MakeFromP3(&result, &pnt);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaVector3 vmathSoaV3MakeFromScalar_V( vec_float4 scalar )
|
||||
{
|
||||
VmathSoaVector3 result;
|
||||
vmathSoaV3MakeFromScalar(&result, scalar);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaVector3 vmathSoaV3MakeFromAos_V( VmathVector3 vec )
|
||||
{
|
||||
VmathSoaVector3 result;
|
||||
vmathSoaV3MakeFromAos(&result, &vec);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaVector3 vmathSoaV3MakeFrom4Aos_V( VmathVector3 vec0, VmathVector3 vec1, VmathVector3 vec2, VmathVector3 vec3 )
|
||||
{
|
||||
VmathSoaVector3 result;
|
||||
vmathSoaV3MakeFrom4Aos(&result, &vec0, &vec1, &vec2, &vec3);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaVector3 vmathSoaV3MakeXAxis_V( )
|
||||
{
|
||||
VmathSoaVector3 result;
|
||||
vmathSoaV3MakeXAxis(&result);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaVector3 vmathSoaV3MakeYAxis_V( )
|
||||
{
|
||||
VmathSoaVector3 result;
|
||||
vmathSoaV3MakeYAxis(&result);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaVector3 vmathSoaV3MakeZAxis_V( )
|
||||
{
|
||||
VmathSoaVector3 result;
|
||||
vmathSoaV3MakeZAxis(&result);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaVector3 vmathSoaV3Lerp_V( vec_float4 t, VmathSoaVector3 vec0, VmathSoaVector3 vec1 )
|
||||
{
|
||||
VmathSoaVector3 result;
|
||||
vmathSoaV3Lerp(&result, t, &vec0, &vec1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaVector3 vmathSoaV3Slerp_V( vec_float4 t, VmathSoaVector3 unitVec0, VmathSoaVector3 unitVec1 )
|
||||
{
|
||||
VmathSoaVector3 result;
|
||||
vmathSoaV3Slerp(&result, t, &unitVec0, &unitVec1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline void vmathSoaV3Get4Aos_V( VmathSoaVector3 vec, VmathVector3 *result0, VmathVector3 *result1, VmathVector3 *result2, VmathVector3 *result3 )
|
||||
{
|
||||
vmathSoaV3Get4Aos(&vec, result0, result1, result2, result3);
|
||||
}
|
||||
|
||||
static inline void vmathSoaV3LoadXYZArray_V( VmathSoaVector3 *vec, const vec_float4 *threeQuads )
|
||||
{
|
||||
vmathSoaV3LoadXYZArray(vec, threeQuads);
|
||||
}
|
||||
|
||||
static inline void vmathSoaV3StoreXYZArray_V( VmathSoaVector3 vec, vec_float4 *threeQuads )
|
||||
{
|
||||
vmathSoaV3StoreXYZArray(&vec, threeQuads);
|
||||
}
|
||||
|
||||
static inline void vmathSoaV3StoreHalfFloats_V( VmathSoaVector3 vec0, VmathSoaVector3 vec1, vec_ushort8 *threeQuads )
|
||||
{
|
||||
vmathSoaV3StoreHalfFloats(&vec0, &vec1, threeQuads);
|
||||
}
|
||||
|
||||
static inline void vmathSoaV3SetX_V( VmathSoaVector3 *result, vec_float4 _x )
|
||||
{
|
||||
vmathSoaV3SetX(result, _x);
|
||||
}
|
||||
|
||||
static inline vec_float4 vmathSoaV3GetX_V( VmathSoaVector3 vec )
|
||||
{
|
||||
return vmathSoaV3GetX(&vec);
|
||||
}
|
||||
|
||||
static inline void vmathSoaV3SetY_V( VmathSoaVector3 *result, vec_float4 _y )
|
||||
{
|
||||
vmathSoaV3SetY(result, _y);
|
||||
}
|
||||
|
||||
static inline vec_float4 vmathSoaV3GetY_V( VmathSoaVector3 vec )
|
||||
{
|
||||
return vmathSoaV3GetY(&vec);
|
||||
}
|
||||
|
||||
static inline void vmathSoaV3SetZ_V( VmathSoaVector3 *result, vec_float4 _z )
|
||||
{
|
||||
vmathSoaV3SetZ(result, _z);
|
||||
}
|
||||
|
||||
static inline vec_float4 vmathSoaV3GetZ_V( VmathSoaVector3 vec )
|
||||
{
|
||||
return vmathSoaV3GetZ(&vec);
|
||||
}
|
||||
|
||||
static inline void vmathSoaV3SetElem_V( VmathSoaVector3 *result, int idx, vec_float4 value )
|
||||
{
|
||||
vmathSoaV3SetElem(result, idx, value);
|
||||
}
|
||||
|
||||
static inline vec_float4 vmathSoaV3GetElem_V( VmathSoaVector3 vec, int idx )
|
||||
{
|
||||
return vmathSoaV3GetElem(&vec, idx);
|
||||
}
|
||||
|
||||
static inline VmathSoaVector3 vmathSoaV3Add_V( VmathSoaVector3 vec0, VmathSoaVector3 vec1 )
|
||||
{
|
||||
VmathSoaVector3 result;
|
||||
vmathSoaV3Add(&result, &vec0, &vec1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaVector3 vmathSoaV3Sub_V( VmathSoaVector3 vec0, VmathSoaVector3 vec1 )
|
||||
{
|
||||
VmathSoaVector3 result;
|
||||
vmathSoaV3Sub(&result, &vec0, &vec1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaPoint3 vmathSoaV3AddP3_V( VmathSoaVector3 vec, VmathSoaPoint3 pnt1 )
|
||||
{
|
||||
VmathSoaPoint3 result;
|
||||
vmathSoaV3AddP3(&result, &vec, &pnt1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaVector3 vmathSoaV3ScalarMul_V( VmathSoaVector3 vec, vec_float4 scalar )
|
||||
{
|
||||
VmathSoaVector3 result;
|
||||
vmathSoaV3ScalarMul(&result, &vec, scalar);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaVector3 vmathSoaV3ScalarDiv_V( VmathSoaVector3 vec, vec_float4 scalar )
|
||||
{
|
||||
VmathSoaVector3 result;
|
||||
vmathSoaV3ScalarDiv(&result, &vec, scalar);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaVector3 vmathSoaV3Neg_V( VmathSoaVector3 vec )
|
||||
{
|
||||
VmathSoaVector3 result;
|
||||
vmathSoaV3Neg(&result, &vec);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaVector3 vmathSoaV3MulPerElem_V( VmathSoaVector3 vec0, VmathSoaVector3 vec1 )
|
||||
{
|
||||
VmathSoaVector3 result;
|
||||
vmathSoaV3MulPerElem(&result, &vec0, &vec1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaVector3 vmathSoaV3DivPerElem_V( VmathSoaVector3 vec0, VmathSoaVector3 vec1 )
|
||||
{
|
||||
VmathSoaVector3 result;
|
||||
vmathSoaV3DivPerElem(&result, &vec0, &vec1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaVector3 vmathSoaV3RecipPerElem_V( VmathSoaVector3 vec )
|
||||
{
|
||||
VmathSoaVector3 result;
|
||||
vmathSoaV3RecipPerElem(&result, &vec);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaVector3 vmathSoaV3SqrtPerElem_V( VmathSoaVector3 vec )
|
||||
{
|
||||
VmathSoaVector3 result;
|
||||
vmathSoaV3SqrtPerElem(&result, &vec);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaVector3 vmathSoaV3RsqrtPerElem_V( VmathSoaVector3 vec )
|
||||
{
|
||||
VmathSoaVector3 result;
|
||||
vmathSoaV3RsqrtPerElem(&result, &vec);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaVector3 vmathSoaV3AbsPerElem_V( VmathSoaVector3 vec )
|
||||
{
|
||||
VmathSoaVector3 result;
|
||||
vmathSoaV3AbsPerElem(&result, &vec);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaVector3 vmathSoaV3CopySignPerElem_V( VmathSoaVector3 vec0, VmathSoaVector3 vec1 )
|
||||
{
|
||||
VmathSoaVector3 result;
|
||||
vmathSoaV3CopySignPerElem(&result, &vec0, &vec1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaVector3 vmathSoaV3MaxPerElem_V( VmathSoaVector3 vec0, VmathSoaVector3 vec1 )
|
||||
{
|
||||
VmathSoaVector3 result;
|
||||
vmathSoaV3MaxPerElem(&result, &vec0, &vec1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline vec_float4 vmathSoaV3MaxElem_V( VmathSoaVector3 vec )
|
||||
{
|
||||
return vmathSoaV3MaxElem(&vec);
|
||||
}
|
||||
|
||||
static inline VmathSoaVector3 vmathSoaV3MinPerElem_V( VmathSoaVector3 vec0, VmathSoaVector3 vec1 )
|
||||
{
|
||||
VmathSoaVector3 result;
|
||||
vmathSoaV3MinPerElem(&result, &vec0, &vec1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline vec_float4 vmathSoaV3MinElem_V( VmathSoaVector3 vec )
|
||||
{
|
||||
return vmathSoaV3MinElem(&vec);
|
||||
}
|
||||
|
||||
static inline vec_float4 vmathSoaV3Sum_V( VmathSoaVector3 vec )
|
||||
{
|
||||
return vmathSoaV3Sum(&vec);
|
||||
}
|
||||
|
||||
static inline vec_float4 vmathSoaV3Dot_V( VmathSoaVector3 vec0, VmathSoaVector3 vec1 )
|
||||
{
|
||||
return vmathSoaV3Dot(&vec0, &vec1);
|
||||
}
|
||||
|
||||
static inline vec_float4 vmathSoaV3LengthSqr_V( VmathSoaVector3 vec )
|
||||
{
|
||||
return vmathSoaV3LengthSqr(&vec);
|
||||
}
|
||||
|
||||
static inline vec_float4 vmathSoaV3Length_V( VmathSoaVector3 vec )
|
||||
{
|
||||
return vmathSoaV3Length(&vec);
|
||||
}
|
||||
|
||||
static inline VmathSoaVector3 vmathSoaV3Normalize_V( VmathSoaVector3 vec )
|
||||
{
|
||||
VmathSoaVector3 result;
|
||||
vmathSoaV3Normalize(&result, &vec);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaVector3 vmathSoaV3Cross_V( VmathSoaVector3 vec0, VmathSoaVector3 vec1 )
|
||||
{
|
||||
VmathSoaVector3 result;
|
||||
vmathSoaV3Cross(&result, &vec0, &vec1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaVector3 vmathSoaV3Select_V( VmathSoaVector3 vec0, VmathSoaVector3 vec1, vec_uint4 select1 )
|
||||
{
|
||||
VmathSoaVector3 result;
|
||||
vmathSoaV3Select(&result, &vec0, &vec1, select1);
|
||||
return result;
|
||||
}
|
||||
|
||||
#ifdef _VECTORMATH_DEBUG
|
||||
|
||||
static inline void vmathSoaV3Print_V( VmathSoaVector3 vec )
|
||||
{
|
||||
vmathSoaV3Print(&vec);
|
||||
}
|
||||
|
||||
static inline void vmathSoaV3Prints_V( VmathSoaVector3 vec, const char *name )
|
||||
{
|
||||
vmathSoaV3Prints(&vec, name);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
static inline VmathSoaVector4 vmathSoaV4MakeFromElems_V( vec_float4 _x, vec_float4 _y, vec_float4 _z, vec_float4 _w )
|
||||
{
|
||||
VmathSoaVector4 result;
|
||||
vmathSoaV4MakeFromElems(&result, _x, _y, _z, _w);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaVector4 vmathSoaV4MakeFromV3Scalar_V( VmathSoaVector3 xyz, vec_float4 _w )
|
||||
{
|
||||
VmathSoaVector4 result;
|
||||
vmathSoaV4MakeFromV3Scalar(&result, &xyz, _w);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaVector4 vmathSoaV4MakeFromV3_V( VmathSoaVector3 vec )
|
||||
{
|
||||
VmathSoaVector4 result;
|
||||
vmathSoaV4MakeFromV3(&result, &vec);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaVector4 vmathSoaV4MakeFromP3_V( VmathSoaPoint3 pnt )
|
||||
{
|
||||
VmathSoaVector4 result;
|
||||
vmathSoaV4MakeFromP3(&result, &pnt);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaVector4 vmathSoaV4MakeFromQ_V( VmathSoaQuat quat )
|
||||
{
|
||||
VmathSoaVector4 result;
|
||||
vmathSoaV4MakeFromQ(&result, &quat);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaVector4 vmathSoaV4MakeFromScalar_V( vec_float4 scalar )
|
||||
{
|
||||
VmathSoaVector4 result;
|
||||
vmathSoaV4MakeFromScalar(&result, scalar);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaVector4 vmathSoaV4MakeFromAos_V( VmathVector4 vec )
|
||||
{
|
||||
VmathSoaVector4 result;
|
||||
vmathSoaV4MakeFromAos(&result, &vec);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaVector4 vmathSoaV4MakeFrom4Aos_V( VmathVector4 vec0, VmathVector4 vec1, VmathVector4 vec2, VmathVector4 vec3 )
|
||||
{
|
||||
VmathSoaVector4 result;
|
||||
vmathSoaV4MakeFrom4Aos(&result, &vec0, &vec1, &vec2, &vec3);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaVector4 vmathSoaV4MakeXAxis_V( )
|
||||
{
|
||||
VmathSoaVector4 result;
|
||||
vmathSoaV4MakeXAxis(&result);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaVector4 vmathSoaV4MakeYAxis_V( )
|
||||
{
|
||||
VmathSoaVector4 result;
|
||||
vmathSoaV4MakeYAxis(&result);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaVector4 vmathSoaV4MakeZAxis_V( )
|
||||
{
|
||||
VmathSoaVector4 result;
|
||||
vmathSoaV4MakeZAxis(&result);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaVector4 vmathSoaV4MakeWAxis_V( )
|
||||
{
|
||||
VmathSoaVector4 result;
|
||||
vmathSoaV4MakeWAxis(&result);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaVector4 vmathSoaV4Lerp_V( vec_float4 t, VmathSoaVector4 vec0, VmathSoaVector4 vec1 )
|
||||
{
|
||||
VmathSoaVector4 result;
|
||||
vmathSoaV4Lerp(&result, t, &vec0, &vec1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaVector4 vmathSoaV4Slerp_V( vec_float4 t, VmathSoaVector4 unitVec0, VmathSoaVector4 unitVec1 )
|
||||
{
|
||||
VmathSoaVector4 result;
|
||||
vmathSoaV4Slerp(&result, t, &unitVec0, &unitVec1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline void vmathSoaV4Get4Aos_V( VmathSoaVector4 vec, VmathVector4 *result0, VmathVector4 *result1, VmathVector4 *result2, VmathVector4 *result3 )
|
||||
{
|
||||
vmathSoaV4Get4Aos(&vec, result0, result1, result2, result3);
|
||||
}
|
||||
|
||||
static inline void vmathSoaV4StoreHalfFloats_V( VmathSoaVector4 vec, vec_ushort8 *twoQuads )
|
||||
{
|
||||
vmathSoaV4StoreHalfFloats(&vec, twoQuads);
|
||||
}
|
||||
|
||||
static inline void vmathSoaV4SetXYZ_V( VmathSoaVector4 *result, VmathSoaVector3 vec )
|
||||
{
|
||||
vmathSoaV4SetXYZ(result, &vec);
|
||||
}
|
||||
|
||||
static inline VmathSoaVector3 vmathSoaV4GetXYZ_V( VmathSoaVector4 vec )
|
||||
{
|
||||
VmathSoaVector3 result;
|
||||
vmathSoaV4GetXYZ(&result, &vec);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline void vmathSoaV4SetX_V( VmathSoaVector4 *result, vec_float4 _x )
|
||||
{
|
||||
vmathSoaV4SetX(result, _x);
|
||||
}
|
||||
|
||||
static inline vec_float4 vmathSoaV4GetX_V( VmathSoaVector4 vec )
|
||||
{
|
||||
return vmathSoaV4GetX(&vec);
|
||||
}
|
||||
|
||||
static inline void vmathSoaV4SetY_V( VmathSoaVector4 *result, vec_float4 _y )
|
||||
{
|
||||
vmathSoaV4SetY(result, _y);
|
||||
}
|
||||
|
||||
static inline vec_float4 vmathSoaV4GetY_V( VmathSoaVector4 vec )
|
||||
{
|
||||
return vmathSoaV4GetY(&vec);
|
||||
}
|
||||
|
||||
static inline void vmathSoaV4SetZ_V( VmathSoaVector4 *result, vec_float4 _z )
|
||||
{
|
||||
vmathSoaV4SetZ(result, _z);
|
||||
}
|
||||
|
||||
static inline vec_float4 vmathSoaV4GetZ_V( VmathSoaVector4 vec )
|
||||
{
|
||||
return vmathSoaV4GetZ(&vec);
|
||||
}
|
||||
|
||||
static inline void vmathSoaV4SetW_V( VmathSoaVector4 *result, vec_float4 _w )
|
||||
{
|
||||
vmathSoaV4SetW(result, _w);
|
||||
}
|
||||
|
||||
static inline vec_float4 vmathSoaV4GetW_V( VmathSoaVector4 vec )
|
||||
{
|
||||
return vmathSoaV4GetW(&vec);
|
||||
}
|
||||
|
||||
static inline void vmathSoaV4SetElem_V( VmathSoaVector4 *result, int idx, vec_float4 value )
|
||||
{
|
||||
vmathSoaV4SetElem(result, idx, value);
|
||||
}
|
||||
|
||||
static inline vec_float4 vmathSoaV4GetElem_V( VmathSoaVector4 vec, int idx )
|
||||
{
|
||||
return vmathSoaV4GetElem(&vec, idx);
|
||||
}
|
||||
|
||||
static inline VmathSoaVector4 vmathSoaV4Add_V( VmathSoaVector4 vec0, VmathSoaVector4 vec1 )
|
||||
{
|
||||
VmathSoaVector4 result;
|
||||
vmathSoaV4Add(&result, &vec0, &vec1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaVector4 vmathSoaV4Sub_V( VmathSoaVector4 vec0, VmathSoaVector4 vec1 )
|
||||
{
|
||||
VmathSoaVector4 result;
|
||||
vmathSoaV4Sub(&result, &vec0, &vec1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaVector4 vmathSoaV4ScalarMul_V( VmathSoaVector4 vec, vec_float4 scalar )
|
||||
{
|
||||
VmathSoaVector4 result;
|
||||
vmathSoaV4ScalarMul(&result, &vec, scalar);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaVector4 vmathSoaV4ScalarDiv_V( VmathSoaVector4 vec, vec_float4 scalar )
|
||||
{
|
||||
VmathSoaVector4 result;
|
||||
vmathSoaV4ScalarDiv(&result, &vec, scalar);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaVector4 vmathSoaV4Neg_V( VmathSoaVector4 vec )
|
||||
{
|
||||
VmathSoaVector4 result;
|
||||
vmathSoaV4Neg(&result, &vec);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaVector4 vmathSoaV4MulPerElem_V( VmathSoaVector4 vec0, VmathSoaVector4 vec1 )
|
||||
{
|
||||
VmathSoaVector4 result;
|
||||
vmathSoaV4MulPerElem(&result, &vec0, &vec1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaVector4 vmathSoaV4DivPerElem_V( VmathSoaVector4 vec0, VmathSoaVector4 vec1 )
|
||||
{
|
||||
VmathSoaVector4 result;
|
||||
vmathSoaV4DivPerElem(&result, &vec0, &vec1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaVector4 vmathSoaV4RecipPerElem_V( VmathSoaVector4 vec )
|
||||
{
|
||||
VmathSoaVector4 result;
|
||||
vmathSoaV4RecipPerElem(&result, &vec);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaVector4 vmathSoaV4SqrtPerElem_V( VmathSoaVector4 vec )
|
||||
{
|
||||
VmathSoaVector4 result;
|
||||
vmathSoaV4SqrtPerElem(&result, &vec);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaVector4 vmathSoaV4RsqrtPerElem_V( VmathSoaVector4 vec )
|
||||
{
|
||||
VmathSoaVector4 result;
|
||||
vmathSoaV4RsqrtPerElem(&result, &vec);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaVector4 vmathSoaV4AbsPerElem_V( VmathSoaVector4 vec )
|
||||
{
|
||||
VmathSoaVector4 result;
|
||||
vmathSoaV4AbsPerElem(&result, &vec);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaVector4 vmathSoaV4CopySignPerElem_V( VmathSoaVector4 vec0, VmathSoaVector4 vec1 )
|
||||
{
|
||||
VmathSoaVector4 result;
|
||||
vmathSoaV4CopySignPerElem(&result, &vec0, &vec1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaVector4 vmathSoaV4MaxPerElem_V( VmathSoaVector4 vec0, VmathSoaVector4 vec1 )
|
||||
{
|
||||
VmathSoaVector4 result;
|
||||
vmathSoaV4MaxPerElem(&result, &vec0, &vec1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline vec_float4 vmathSoaV4MaxElem_V( VmathSoaVector4 vec )
|
||||
{
|
||||
return vmathSoaV4MaxElem(&vec);
|
||||
}
|
||||
|
||||
static inline VmathSoaVector4 vmathSoaV4MinPerElem_V( VmathSoaVector4 vec0, VmathSoaVector4 vec1 )
|
||||
{
|
||||
VmathSoaVector4 result;
|
||||
vmathSoaV4MinPerElem(&result, &vec0, &vec1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline vec_float4 vmathSoaV4MinElem_V( VmathSoaVector4 vec )
|
||||
{
|
||||
return vmathSoaV4MinElem(&vec);
|
||||
}
|
||||
|
||||
static inline vec_float4 vmathSoaV4Sum_V( VmathSoaVector4 vec )
|
||||
{
|
||||
return vmathSoaV4Sum(&vec);
|
||||
}
|
||||
|
||||
static inline vec_float4 vmathSoaV4Dot_V( VmathSoaVector4 vec0, VmathSoaVector4 vec1 )
|
||||
{
|
||||
return vmathSoaV4Dot(&vec0, &vec1);
|
||||
}
|
||||
|
||||
static inline vec_float4 vmathSoaV4LengthSqr_V( VmathSoaVector4 vec )
|
||||
{
|
||||
return vmathSoaV4LengthSqr(&vec);
|
||||
}
|
||||
|
||||
static inline vec_float4 vmathSoaV4Length_V( VmathSoaVector4 vec )
|
||||
{
|
||||
return vmathSoaV4Length(&vec);
|
||||
}
|
||||
|
||||
static inline VmathSoaVector4 vmathSoaV4Normalize_V( VmathSoaVector4 vec )
|
||||
{
|
||||
VmathSoaVector4 result;
|
||||
vmathSoaV4Normalize(&result, &vec);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaVector4 vmathSoaV4Select_V( VmathSoaVector4 vec0, VmathSoaVector4 vec1, vec_uint4 select1 )
|
||||
{
|
||||
VmathSoaVector4 result;
|
||||
vmathSoaV4Select(&result, &vec0, &vec1, select1);
|
||||
return result;
|
||||
}
|
||||
|
||||
#ifdef _VECTORMATH_DEBUG
|
||||
|
||||
static inline void vmathSoaV4Print_V( VmathSoaVector4 vec )
|
||||
{
|
||||
vmathSoaV4Print(&vec);
|
||||
}
|
||||
|
||||
static inline void vmathSoaV4Prints_V( VmathSoaVector4 vec, const char *name )
|
||||
{
|
||||
vmathSoaV4Prints(&vec, name);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
static inline VmathSoaPoint3 vmathSoaP3MakeFromElems_V( vec_float4 _x, vec_float4 _y, vec_float4 _z )
|
||||
{
|
||||
VmathSoaPoint3 result;
|
||||
vmathSoaP3MakeFromElems(&result, _x, _y, _z);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaPoint3 vmathSoaP3MakeFromV3_V( VmathSoaVector3 vec )
|
||||
{
|
||||
VmathSoaPoint3 result;
|
||||
vmathSoaP3MakeFromV3(&result, &vec);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaPoint3 vmathSoaP3MakeFromScalar_V( vec_float4 scalar )
|
||||
{
|
||||
VmathSoaPoint3 result;
|
||||
vmathSoaP3MakeFromScalar(&result, scalar);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaPoint3 vmathSoaP3MakeFromAos_V( VmathPoint3 pnt )
|
||||
{
|
||||
VmathSoaPoint3 result;
|
||||
vmathSoaP3MakeFromAos(&result, &pnt);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaPoint3 vmathSoaP3MakeFrom4Aos_V( VmathPoint3 pnt0, VmathPoint3 pnt1, VmathPoint3 pnt2, VmathPoint3 pnt3 )
|
||||
{
|
||||
VmathSoaPoint3 result;
|
||||
vmathSoaP3MakeFrom4Aos(&result, &pnt0, &pnt1, &pnt2, &pnt3);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaPoint3 vmathSoaP3Lerp_V( vec_float4 t, VmathSoaPoint3 pnt0, VmathSoaPoint3 pnt1 )
|
||||
{
|
||||
VmathSoaPoint3 result;
|
||||
vmathSoaP3Lerp(&result, t, &pnt0, &pnt1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline void vmathSoaP3Get4Aos_V( VmathSoaPoint3 pnt, VmathPoint3 *result0, VmathPoint3 *result1, VmathPoint3 *result2, VmathPoint3 *result3 )
|
||||
{
|
||||
vmathSoaP3Get4Aos(&pnt, result0, result1, result2, result3);
|
||||
}
|
||||
|
||||
static inline void vmathSoaP3LoadXYZArray_V( VmathSoaPoint3 *vec, const vec_float4 *threeQuads )
|
||||
{
|
||||
vmathSoaP3LoadXYZArray(vec, threeQuads);
|
||||
}
|
||||
|
||||
static inline void vmathSoaP3StoreXYZArray_V( VmathSoaPoint3 vec, vec_float4 *threeQuads )
|
||||
{
|
||||
vmathSoaP3StoreXYZArray(&vec, threeQuads);
|
||||
}
|
||||
|
||||
static inline void vmathSoaP3StoreHalfFloats_V( VmathSoaPoint3 pnt0, VmathSoaPoint3 pnt1, vec_ushort8 *threeQuads )
|
||||
{
|
||||
vmathSoaP3StoreHalfFloats(&pnt0, &pnt1, threeQuads);
|
||||
}
|
||||
|
||||
static inline void vmathSoaP3SetX_V( VmathSoaPoint3 *result, vec_float4 _x )
|
||||
{
|
||||
vmathSoaP3SetX(result, _x);
|
||||
}
|
||||
|
||||
static inline vec_float4 vmathSoaP3GetX_V( VmathSoaPoint3 pnt )
|
||||
{
|
||||
return vmathSoaP3GetX(&pnt);
|
||||
}
|
||||
|
||||
static inline void vmathSoaP3SetY_V( VmathSoaPoint3 *result, vec_float4 _y )
|
||||
{
|
||||
vmathSoaP3SetY(result, _y);
|
||||
}
|
||||
|
||||
static inline vec_float4 vmathSoaP3GetY_V( VmathSoaPoint3 pnt )
|
||||
{
|
||||
return vmathSoaP3GetY(&pnt);
|
||||
}
|
||||
|
||||
static inline void vmathSoaP3SetZ_V( VmathSoaPoint3 *result, vec_float4 _z )
|
||||
{
|
||||
vmathSoaP3SetZ(result, _z);
|
||||
}
|
||||
|
||||
static inline vec_float4 vmathSoaP3GetZ_V( VmathSoaPoint3 pnt )
|
||||
{
|
||||
return vmathSoaP3GetZ(&pnt);
|
||||
}
|
||||
|
||||
static inline void vmathSoaP3SetElem_V( VmathSoaPoint3 *result, int idx, vec_float4 value )
|
||||
{
|
||||
vmathSoaP3SetElem(result, idx, value);
|
||||
}
|
||||
|
||||
static inline vec_float4 vmathSoaP3GetElem_V( VmathSoaPoint3 pnt, int idx )
|
||||
{
|
||||
return vmathSoaP3GetElem(&pnt, idx);
|
||||
}
|
||||
|
||||
static inline VmathSoaVector3 vmathSoaP3Sub_V( VmathSoaPoint3 pnt0, VmathSoaPoint3 pnt1 )
|
||||
{
|
||||
VmathSoaVector3 result;
|
||||
vmathSoaP3Sub(&result, &pnt0, &pnt1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaPoint3 vmathSoaP3AddV3_V( VmathSoaPoint3 pnt, VmathSoaVector3 vec1 )
|
||||
{
|
||||
VmathSoaPoint3 result;
|
||||
vmathSoaP3AddV3(&result, &pnt, &vec1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaPoint3 vmathSoaP3SubV3_V( VmathSoaPoint3 pnt, VmathSoaVector3 vec1 )
|
||||
{
|
||||
VmathSoaPoint3 result;
|
||||
vmathSoaP3SubV3(&result, &pnt, &vec1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaPoint3 vmathSoaP3MulPerElem_V( VmathSoaPoint3 pnt0, VmathSoaPoint3 pnt1 )
|
||||
{
|
||||
VmathSoaPoint3 result;
|
||||
vmathSoaP3MulPerElem(&result, &pnt0, &pnt1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaPoint3 vmathSoaP3DivPerElem_V( VmathSoaPoint3 pnt0, VmathSoaPoint3 pnt1 )
|
||||
{
|
||||
VmathSoaPoint3 result;
|
||||
vmathSoaP3DivPerElem(&result, &pnt0, &pnt1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaPoint3 vmathSoaP3RecipPerElem_V( VmathSoaPoint3 pnt )
|
||||
{
|
||||
VmathSoaPoint3 result;
|
||||
vmathSoaP3RecipPerElem(&result, &pnt);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaPoint3 vmathSoaP3SqrtPerElem_V( VmathSoaPoint3 pnt )
|
||||
{
|
||||
VmathSoaPoint3 result;
|
||||
vmathSoaP3SqrtPerElem(&result, &pnt);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaPoint3 vmathSoaP3RsqrtPerElem_V( VmathSoaPoint3 pnt )
|
||||
{
|
||||
VmathSoaPoint3 result;
|
||||
vmathSoaP3RsqrtPerElem(&result, &pnt);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaPoint3 vmathSoaP3AbsPerElem_V( VmathSoaPoint3 pnt )
|
||||
{
|
||||
VmathSoaPoint3 result;
|
||||
vmathSoaP3AbsPerElem(&result, &pnt);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaPoint3 vmathSoaP3CopySignPerElem_V( VmathSoaPoint3 pnt0, VmathSoaPoint3 pnt1 )
|
||||
{
|
||||
VmathSoaPoint3 result;
|
||||
vmathSoaP3CopySignPerElem(&result, &pnt0, &pnt1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaPoint3 vmathSoaP3MaxPerElem_V( VmathSoaPoint3 pnt0, VmathSoaPoint3 pnt1 )
|
||||
{
|
||||
VmathSoaPoint3 result;
|
||||
vmathSoaP3MaxPerElem(&result, &pnt0, &pnt1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline vec_float4 vmathSoaP3MaxElem_V( VmathSoaPoint3 pnt )
|
||||
{
|
||||
return vmathSoaP3MaxElem(&pnt);
|
||||
}
|
||||
|
||||
static inline VmathSoaPoint3 vmathSoaP3MinPerElem_V( VmathSoaPoint3 pnt0, VmathSoaPoint3 pnt1 )
|
||||
{
|
||||
VmathSoaPoint3 result;
|
||||
vmathSoaP3MinPerElem(&result, &pnt0, &pnt1);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline vec_float4 vmathSoaP3MinElem_V( VmathSoaPoint3 pnt )
|
||||
{
|
||||
return vmathSoaP3MinElem(&pnt);
|
||||
}
|
||||
|
||||
static inline vec_float4 vmathSoaP3Sum_V( VmathSoaPoint3 pnt )
|
||||
{
|
||||
return vmathSoaP3Sum(&pnt);
|
||||
}
|
||||
|
||||
static inline VmathSoaPoint3 vmathSoaP3Scale_V( VmathSoaPoint3 pnt, vec_float4 scaleVal )
|
||||
{
|
||||
VmathSoaPoint3 result;
|
||||
vmathSoaP3Scale(&result, &pnt, scaleVal);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline VmathSoaPoint3 vmathSoaP3NonUniformScale_V( VmathSoaPoint3 pnt, VmathSoaVector3 scaleVec )
|
||||
{
|
||||
VmathSoaPoint3 result;
|
||||
vmathSoaP3NonUniformScale(&result, &pnt, &scaleVec);
|
||||
return result;
|
||||
}
|
||||
|
||||
static inline vec_float4 vmathSoaP3Projection_V( VmathSoaPoint3 pnt, VmathSoaVector3 unitVec )
|
||||
{
|
||||
return vmathSoaP3Projection(&pnt, &unitVec);
|
||||
}
|
||||
|
||||
static inline vec_float4 vmathSoaP3DistSqrFromOrigin_V( VmathSoaPoint3 pnt )
|
||||
{
|
||||
return vmathSoaP3DistSqrFromOrigin(&pnt);
|
||||
}
|
||||
|
||||
static inline vec_float4 vmathSoaP3DistFromOrigin_V( VmathSoaPoint3 pnt )
|
||||
{
|
||||
return vmathSoaP3DistFromOrigin(&pnt);
|
||||
}
|
||||
|
||||
static inline vec_float4 vmathSoaP3DistSqr_V( VmathSoaPoint3 pnt0, VmathSoaPoint3 pnt1 )
|
||||
{
|
||||
return vmathSoaP3DistSqr(&pnt0, &pnt1);
|
||||
}
|
||||
|
||||
static inline vec_float4 vmathSoaP3Dist_V( VmathSoaPoint3 pnt0, VmathSoaPoint3 pnt1 )
|
||||
{
|
||||
return vmathSoaP3Dist(&pnt0, &pnt1);
|
||||
}
|
||||
|
||||
static inline VmathSoaPoint3 vmathSoaP3Select_V( VmathSoaPoint3 pnt0, VmathSoaPoint3 pnt1, vec_uint4 select1 )
|
||||
{
|
||||
VmathSoaPoint3 result;
|
||||
vmathSoaP3Select(&result, &pnt0, &pnt1, select1);
|
||||
return result;
|
||||
}
|
||||
|
||||
#ifdef _VECTORMATH_DEBUG
|
||||
|
||||
static inline void vmathSoaP3Print_V( VmathSoaPoint3 pnt )
|
||||
{
|
||||
vmathSoaP3Print(&pnt);
|
||||
}
|
||||
|
||||
static inline void vmathSoaP3Prints_V( VmathSoaPoint3 pnt, const char *name )
|
||||
{
|
||||
vmathSoaP3Prints(&pnt, name);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#endif
|
||||
1952
Extras/vectormathlibrary/include/vectormath/spu/c/vectormath_aos.h
Normal file
1952
Extras/vectormathlibrary/include/vectormath/spu/c/vectormath_aos.h
Normal file
File diff suppressed because it is too large
Load Diff
1916
Extras/vectormathlibrary/include/vectormath/spu/c/vectormath_aos_v.h
Normal file
1916
Extras/vectormathlibrary/include/vectormath/spu/c/vectormath_aos_v.h
Normal file
File diff suppressed because it is too large
Load Diff
2012
Extras/vectormathlibrary/include/vectormath/spu/c/vectormath_soa.h
Normal file
2012
Extras/vectormathlibrary/include/vectormath/spu/c/vectormath_soa.h
Normal file
File diff suppressed because it is too large
Load Diff
1978
Extras/vectormathlibrary/include/vectormath/spu/c/vectormath_soa_v.h
Normal file
1978
Extras/vectormathlibrary/include/vectormath/spu/c/vectormath_soa_v.h
Normal file
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user