xsi_vector3f.h
Go to the documentation of this file.

    00001 //*****************************************************************************
    00011 //*****************************************************************************
    00012
    00013 #if (_MSC_VER > 1000) || defined(SGI_COMPILER)
    00014 #pragma once
    00015 #endif
    00016
    00017 #ifndef __XSIVECTOR3F_H__
    00018 #define __XSIVECTOR3F_H__
    00019
    00020 #include "sicppsdk.h"
    00021 #include <xsi_math.h>
    00022 #include <xsi_matrix3f.h>
    00023 #include <xsi_matrix4f.h>
    00024
    00025 namespace XSI {
    00026
    00027 namespace MATH {
    00028
    00029 //*****************************************************************************
    00036 //*****************************************************************************
    00037 class CVector3f
    00038 {
    00039 public:
    00041     SICPPSDK_INLINE CVector3f();
    00042
    00048     SICPPSDK_INLINE CVector3f(float in_fX, float in_fY, float in_fZ);
    00049
    00053     SICPPSDK_INLINE CVector3f( const CVector3f& in_vector3);
    00054
    00056     SICPPSDK_INLINE ~CVector3f();
    00057
    00062     SICPPSDK_INLINE CVector3f & operator=( const CVector3f & in_vector3 );
    00063
    00069     SICPPSDK_INLINE bool operator ==(const CVector3f & in_vector3 )const;
    00070
    00076     SICPPSDK_INLINE bool operator !=(const CVector3f & in_vector3 )const;
    00077
    00082     SICPPSDK_INLINE CVector3f& operator ~();
    00083
    00089     SICPPSDK_INLINE CVector3f& operator +=(const CVector3f& in_vector3);
    00090
    00096     SICPPSDK_INLINE CVector3f& operator -=(const CVector3f & in_vector3);
    00097
    00103     SICPPSDK_INLINE CVector3f& operator *=(const CMatrix3f& in_matrix3);
    00104
    00110     SICPPSDK_INLINE CVector3f& operator *=(const CMatrix4f& in_matrix4);
    00111
    00117     SICPPSDK_INLINE CVector3f& operator *=(const float in_fAlpha);
    00118
    00124     SICPPSDK_INLINE float operator[](const short& in_sIndex) const;
    00125
    00131     SICPPSDK_INLINE float& operator[](const short& in_sIndex);
    00132
    00140     SICPPSDK_INLINE bool operator < ( const CVector3f & in_vector3 ) const;
    00141
    00146     SICPPSDK_INLINE CVector3f& MulByMatrix3InPlace(const CMatrix3f& in_matrix3);
    00147
    00153     SICPPSDK_INLINE CVector3f& MulByMatrix3( const CVector3f& in_vector3, const CMatrix3f& in_matrix3 );
    00154
    00159     SICPPSDK_INLINE CVector3f& MulByMatrix4InPlace(const CMatrix4f& in_matrix4);
    00160
    00166     SICPPSDK_INLINE CVector3f& MulByMatrix4( const CVector3f& in_vector3, const CMatrix4f& in_matrix4 );
    00167
    00171     SICPPSDK_INLINE CVector3f& SetNull();
    00172
    00177     SICPPSDK_INLINE bool IsNull(const float in_fEpsilon = MicroEPS);
    00178
    00182     SICPPSDK_INLINE short GetMaxComponentIndex()const;
    00183
    00187     SICPPSDK_INLINE float GetMaxComponent()const;
    00188
    00192     SICPPSDK_INLINE short GetMinComponentIndex()const;
    00193
    00197     SICPPSDK_INLINE float GetMinComponent()const;
    00198
    00202     SICPPSDK_INLINE float GetLength()const;
    00203
    00207     SICPPSDK_INLINE void SetLength( const float in_val );
    00208
    00212     SICPPSDK_INLINE float GetLengthSquared()const;
    00213
    00217     SICPPSDK_INLINE CStatus NormalizeInPlace();
    00218
    00223     SICPPSDK_INLINE CStatus Normalize(const CVector3f& in_vector3);
    00224
    00229     SICPPSDK_INLINE float Dot(const CVector3f& in_vector3)const;
    00230
    00236     SICPPSDK_INLINE CVector3f& Cross(const CVector3f& in_vector3A, const CVector3f& in_vector3B);
    00237
    00242     SICPPSDK_INLINE float GetAngle(const CVector3f& in_vector3 )const;
    00243
    00252     SICPPSDK_INLINE CVector3f& LinearlyInterpolate
    00253     (
    00254         const CVector3f& in_vector3A,
    00255         const CVector3f& in_vector3B,
    00256         const float in_fAlpha
    00257     );
    00258
    00262     SICPPSDK_INLINE CVector3f& AbsoluteInPlace();
    00263
    00269     SICPPSDK_INLINE CVector3f& Absolute(const CVector3f& in_vector3);
    00270
    00276     SICPPSDK_INLINE CVector3f& ClampInPlace(const float in_fMinValue, const float in_fMaxValue);
    00277
    00285     SICPPSDK_INLINE CVector3f& Clamp
    00286     (
    00287         const float         in_fMinValue,
    00288         const float         in_fMaxValue,
    00289         const CVector3f&    in_vector3
    00290     );
    00291
    00297     SICPPSDK_INLINE bool EpsilonEquals
    00298     (
    00299         const CVector3f& in_vector3,
    00300         const float in_fEpsilon
    00301     )const;
    00302
    00307     SICPPSDK_INLINE bool Equals(const CVector3f& in_vector3)const;
    00308
    00315     SICPPSDK_INLINE CVector3f& ScaleAddInPlace(const float in_fS,const CVector3f& in_vector3);
    00316
    00324     SICPPSDK_INLINE CVector3f& ScaleAdd
    00325     (
    00326         const float             in_fS,
    00327         const CVector3f&        in_vector3A,
    00328         const CVector3f&        in_vector3B
    00329     );
    00330
    00335     SICPPSDK_INLINE CVector3f& ScaleInPlace(const float in_fAlpha);
    00336
    00342     SICPPSDK_INLINE CVector3f& Scale(const float in_fAlpha, const CVector3f& in_vector3);
    00343
    00347     SICPPSDK_INLINE CVector3f& NegateInPlace();
    00348
    00353     SICPPSDK_INLINE CVector3f& Negate(const CVector3f& in_vector3);
    00354
    00359     SICPPSDK_INLINE CVector3f& SubInPlace(const CVector3f&in_vector3);
    00360
    00367     SICPPSDK_INLINE CVector3f& Sub(const CVector3f& in_vector3A, const CVector3f& in_vector3B);
    00368
    00373     SICPPSDK_INLINE CVector3f& AddInPlace(const CVector3f& in_vector3);
    00374
    00380     SICPPSDK_INLINE CVector3f& Add(const CVector3f& in_vector3A,const CVector3f& in_vector3B);
    00381
    00387     SICPPSDK_INLINE float Get(const short& in_sIndex)const;
    00388
    00394     SICPPSDK_INLINE void Set(const short& in_sIndex, const float in_val );
    00395
    00401     SICPPSDK_INLINE void Get(float& io_fX, float& io_fY, float& io_fZ)const;
    00402
    00409     SICPPSDK_INLINE CVector3f& Set(const float in_fX, const float in_fY, const float in_fZ);
    00410
    00414     SICPPSDK_INLINE float GetZ()const;
    00415
    00420     SICPPSDK_INLINE CVector3f& PutZ(const float in_fZ);
    00421
    00425     SICPPSDK_INLINE float GetY()const;
    00426
    00431     SICPPSDK_INLINE CVector3f& PutY(const float in_fY);
    00432
    00436     SICPPSDK_INLINE float GetX()const;
    00437
    00442     SICPPSDK_INLINE CVector3f& PutX(const float in_fX);
    00443
    00444 private:
    00445     float m_fX,m_fY,m_fZ;
    00446 };
    00447
    00448 //inline functions
    00449 SICPPSDK_INLINE CVector3f::CVector3f()
    00450 {
    00451     m_fX = 0;
    00452     m_fY = 0;
    00453     m_fZ = 0;
    00454 }
    00455
    00456 SICPPSDK_INLINE CVector3f::CVector3f( const CVector3f& in_vct )
    00457 {
    00458     in_vct.Get(m_fX,m_fY,m_fZ);
    00459 }
    00460
    00461 SICPPSDK_INLINE CVector3f::CVector3f
    00462 (
    00463  float in_fX, float in_fY, float in_fZ
    00464 ):m_fX(in_fX),m_fY(in_fY),m_fZ(in_fZ)
    00465 {}
    00466
    00467 SICPPSDK_INLINE CVector3f::~CVector3f()
    00468 {}
    00469
    00470 SICPPSDK_INLINE CVector3f& CVector3f::operator=( const CVector3f & in_vct )
    00471 {
    00472     in_vct.Get(m_fX,m_fY,m_fZ);
    00473     return (*this);
    00474 }
    00475
    00476 SICPPSDK_INLINE bool CVector3f::operator ==(const CVector3f & in_vector3 )const
    00477 {
    00478     return Equals(in_vector3);
    00479 }
    00480
    00481 SICPPSDK_INLINE bool CVector3f::operator !=(const CVector3f & in_vector3 )const
    00482 {
    00483     return ! Equals(in_vector3);
    00484 }
    00485
    00486 SICPPSDK_INLINE CVector3f& CVector3f::operator ~()
    00487 {
    00488     return NegateInPlace();
    00489 }
    00490
    00491 SICPPSDK_INLINE CVector3f& CVector3f::operator +=(const CVector3f& in_vector3)
    00492 {
    00493     return AddInPlace(in_vector3);
    00494 }
    00495
    00496 SICPPSDK_INLINE CVector3f& CVector3f::operator -=(const CVector3f& in_vector3)
    00497 {
    00498     return SubInPlace(in_vector3);
    00499 }
    00500
    00501 SICPPSDK_INLINE CVector3f& CVector3f::operator *=(const CMatrix3f& in_matrix3)
    00502 {
    00503     return MulByMatrix3InPlace(in_matrix3);
    00504 }
    00505
    00506 SICPPSDK_INLINE CVector3f& CVector3f::operator *=(const CMatrix4f& in_matrix4)
    00507 {
    00508     return MulByMatrix4InPlace(in_matrix4);
    00509 }
    00510
    00511 SICPPSDK_INLINE CVector3f& CVector3f::operator *=(const float in_fAlpha)
    00512 {
    00513     return ScaleInPlace(in_fAlpha);
    00514 }
    00515
    00516 SICPPSDK_INLINE float CVector3f::operator[](const short& in_sIndex) const
    00517 {
    00518     assert(in_sIndex >= 0 && in_sIndex < 3);
    00519     switch(in_sIndex)
    00520     {
    00521         case 0:
    00522             return m_fX;
    00523             break;
    00524         case 1:
    00525             return m_fY;
    00526             break;
    00527         case 2:
    00528             return m_fZ;
    00529             break;
    00530     }
    00531     return FLT_MAX;
    00532 }
    00533
    00534 SICPPSDK_INLINE float& CVector3f::operator[](const short& in_sIndex)
    00535 {
    00536     assert(in_sIndex >= 0 && in_sIndex < 3);
    00537     switch(in_sIndex)
    00538     {
    00539         case 0:
    00540             return m_fX;
    00541             break;
    00542         case 1:
    00543             return m_fY;
    00544             break;
    00545         case 2:
    00546             return m_fZ;
    00547             break;
    00548     }
    00549     static float fMAX = FLT_MAX;
    00550     return fMAX;
    00551 }
    00552
    00553 SICPPSDK_INLINE bool CVector3f::operator < ( const CVector3f& in_v3f) const
    00554 {
    00555     if ( m_fZ != in_v3f.m_fZ ) return m_fZ < in_v3f.m_fZ;
    00556     if ( m_fY != in_v3f.m_fY ) return m_fY < in_v3f.m_fY;
    00557     if ( m_fX != in_v3f.m_fX ) return m_fX < in_v3f.m_fX;
    00558     return false;
    00559 }
    00560
    00561 SICPPSDK_INLINE float CVector3f::Get(const short& in_sIndex) const
    00562 {
    00563     assert(in_sIndex >= 0 && in_sIndex < 3);
    00564     switch(in_sIndex)
    00565     {
    00566         case 0:
    00567             return m_fX;
    00568             break;
    00569         case 1:
    00570             return m_fY;
    00571             break;
    00572         case 2:
    00573             return m_fZ;
    00574             break;
    00575     }
    00576     return FLT_MAX;
    00577 }
    00578
    00579 SICPPSDK_INLINE void CVector3f::Set(const short& in_sIndex, const float in_value )
    00580 {
    00581     assert(in_sIndex >= 0 && in_sIndex < 3);
    00582     switch(in_sIndex)
    00583     {
    00584         case 0:
    00585             m_fX = in_value;
    00586             break;
    00587         case 1:
    00588             m_fY = in_value;
    00589             break;
    00590         case 2:
    00591             m_fZ = in_value;
    00592             break;
    00593     }
    00594 }
    00595
    00596 SICPPSDK_INLINE CVector3f& CVector3f::MulByMatrix3InPlace(const CMatrix3f& in_matrix3)
    00597 {
    00598     return MulByMatrix3((*this),in_matrix3);
    00599 }
    00600
    00601 SICPPSDK_INLINE CVector3f& CVector3f::MulByMatrix3
    00602 (
    00603     const CVector3f& in_vector3,
    00604     const CMatrix3f& in_matrix3
    00605 )
    00606 {
    00607     float l_fX, l_fY,l_fZ;
    00608     l_fX = in_vector3.GetX() * in_matrix3.GetValue(0,0) +
    00609            in_vector3.GetY() * in_matrix3.GetValue(1,0) +
    00610            in_vector3.GetZ() * in_matrix3.GetValue(2,0);
    00611     l_fY = in_vector3.GetX() * in_matrix3.GetValue(0,1) +
    00612            in_vector3.GetY() * in_matrix3.GetValue(1,1) +
    00613            in_vector3.GetZ() * in_matrix3.GetValue(2,1);
    00614     l_fZ = in_vector3.GetX() * in_matrix3.GetValue(0,2) +
    00615            in_vector3.GetY() * in_matrix3.GetValue(1,2) +
    00616            in_vector3.GetZ() * in_matrix3.GetValue(2,2);
    00617
    00618     return Set(l_fX,l_fY,l_fZ);
    00619 }
    00620
    00621 SICPPSDK_INLINE CVector3f& CVector3f::MulByMatrix4InPlace(const CMatrix4f& in_matrix4)
    00622 {
    00623     return MulByMatrix4((*this),in_matrix4);
    00624 }
    00625
    00626 SICPPSDK_INLINE CVector3f& CVector3f::MulByMatrix4
    00627 (
    00628     const CVector3f& in_vector3,
    00629     const CMatrix4f& in_matrix4
    00630 )
    00631 {
    00632     float l_fX, l_fY, l_fZ, l_fW;
    00633
    00634     l_fX =  in_vector3.GetX() * in_matrix4.GetValue( 0, 0 ) +
    00635             in_vector3.GetY() * in_matrix4.GetValue( 1, 0 ) +
    00636             in_vector3.GetZ() * in_matrix4.GetValue( 2, 0 ) +
    00637             in_matrix4.GetValue( 3, 0 );
    00638     l_fY =  in_vector3.GetX() * in_matrix4.GetValue( 0, 1 ) +
    00639             in_vector3.GetY() * in_matrix4.GetValue( 1, 1 ) +
    00640             in_vector3.GetZ() * in_matrix4.GetValue( 2, 1 ) +
    00641             in_matrix4.GetValue( 3, 1 );
    00642     l_fZ =  in_vector3.GetX() * in_matrix4.GetValue( 0, 2 ) +
    00643             in_vector3.GetY() * in_matrix4.GetValue( 1, 2 ) +
    00644             in_vector3.GetZ() * in_matrix4.GetValue( 2, 2 ) +
    00645             in_matrix4.GetValue( 3, 2 );
    00646     l_fW =  in_vector3.GetX() * in_matrix4.GetValue( 0, 3 ) +
    00647             in_vector3.GetY() * in_matrix4.GetValue( 1, 3 ) +
    00648             in_vector3.GetZ() * in_matrix4.GetValue( 2, 3 ) +
    00649             in_matrix4.GetValue( 3, 3 );
    00650
    00651     return Set(l_fX/l_fW, l_fY/l_fW, l_fZ/l_fW);
    00652 }
    00653
    00654 SICPPSDK_INLINE CVector3f& CVector3f::SetNull()
    00655 {
    00656     m_fX = m_fY = m_fZ = 0.0;
    00657     return (*this);
    00658 }
    00659
    00660 SICPPSDK_INLINE bool CVector3f::IsNull( const float in_fEpsilon )
    00661 {
    00662     return( fabs(m_fX) <= in_fEpsilon && fabs(m_fY)<= in_fEpsilon && fabs(m_fZ)<= in_fEpsilon );
    00663 }
    00664
    00665 SICPPSDK_INLINE short CVector3f::GetMaxComponentIndex()const
    00666 {
    00667     if( m_fX > m_fY )
    00668     {
    00669         return (short)(( m_fX > m_fZ ) ? 0 : 2);
    00670     }
    00671     else
    00672     {
    00673         return (short)(( m_fY > m_fZ ) ? 1 : 2);
    00674     }
    00675     return 0;
    00676 }
    00677
    00678 SICPPSDK_INLINE float CVector3f::GetMaxComponent()const
    00679 {
    00680     if( m_fX > m_fY )
    00681     {
    00682         return ( m_fX > m_fZ ) ? m_fX : m_fZ;
    00683     }
    00684     else
    00685     {
    00686         return ( m_fY > m_fZ ) ? m_fY : m_fZ;
    00687     }
    00688     return 0.0;
    00689 }
    00690
    00691 SICPPSDK_INLINE short CVector3f::GetMinComponentIndex()const
    00692 {
    00693     if( m_fX < m_fY )
    00694     {
    00695         return (short)(( m_fX < m_fZ ) ? 0 : 2);
    00696     }
    00697     else
    00698     {
    00699         return (short)(( m_fY < m_fZ ) ? 1 : 2);
    00700     }
    00701     return 0;
    00702 }
    00703
    00704 SICPPSDK_INLINE float CVector3f::GetMinComponent()const
    00705 {
    00706     if( m_fX < m_fY )
    00707     {
    00708         return ( m_fX < m_fZ ) ? m_fX : m_fZ;
    00709     }
    00710     else
    00711     {
    00712         return ( m_fY < m_fZ ) ? m_fY : m_fZ;
    00713     }
    00714     return 0.0;
    00715 }
    00716
    00717 SICPPSDK_INLINE float CVector3f::GetLength()const
    00718 {
    00719     return sqrt( GetLengthSquared() );
    00720 }
    00721
    00722 SICPPSDK_INLINE void CVector3f::SetLength(const float in_val)
    00723 {
    00724     float rLen = GetLength();
    00725
    00726     if ( rLen > MicroEPS )
    00727     {
    00728         ScaleInPlace( in_val / rLen );
    00729     }
    00730 }
    00731
    00732 SICPPSDK_INLINE float CVector3f::GetLengthSquared()const
    00733 {
    00734     return(m_fX*m_fX + m_fY*m_fY + m_fZ*m_fZ );
    00735 }
    00736
    00737 SICPPSDK_INLINE float CVector3f::Dot(const CVector3f& io_vec3)const
    00738 {
    00739     return ( m_fX*io_vec3.GetX() + m_fY*io_vec3.GetY() + m_fZ*io_vec3.GetZ() );
    00740 }
    00741
    00742 SICPPSDK_INLINE CVector3f& CVector3f::Cross
    00743 (
    00744     const CVector3f& in_vec3A,
    00745     const CVector3f& in_vec3B
    00746 )
    00747 {
    00748     float dX, dY, dZ;
    00749
    00750     dX =    in_vec3A.GetY() * in_vec3B.GetZ() -
    00751             in_vec3A.GetZ() * in_vec3B.GetY();
    00752     dY =   -in_vec3A.GetX() * in_vec3B.GetZ() +
    00753             in_vec3A.GetZ() * in_vec3B.GetX();
    00754     dZ =    in_vec3A.GetX() * in_vec3B.GetY() -
    00755             in_vec3A.GetY() * in_vec3B.GetX();
    00756
    00757    return( Set( dX, dY, dZ ) );
    00758 }
    00759
    00760 SICPPSDK_INLINE CVector3f& CVector3f::LinearlyInterpolate
    00761 (
    00762     const CVector3f&    in_vec3A,
    00763     const CVector3f&    in_vec3B,
    00764     const float         in_fAlpha
    00765 )
    00766 {
    00767     m_fX = (1 - in_fAlpha) * in_vec3A.GetX() + in_fAlpha * in_vec3B.GetX();
    00768     m_fY = (1 - in_fAlpha) * in_vec3A.GetY() + in_fAlpha * in_vec3B.GetY();
    00769     m_fZ = (1 - in_fAlpha) * in_vec3A.GetZ() + in_fAlpha * in_vec3B.GetZ();
    00770
    00771     return (*this);
    00772 }
    00773
    00774 SICPPSDK_INLINE bool CVector3f::EpsilonEquals
    00775 (
    00776     const CVector3f& in_cVec3,
    00777     const float in_fEpsilon
    00778 )const
    00779 {
    00780     return (this == &in_cVec3) ? true :
    00781         (fabs( m_fX - in_cVec3.GetX() ) < ::fabs(in_fEpsilon) &&
    00782            fabs( m_fY - in_cVec3.GetY() ) < ::fabs(in_fEpsilon) &&
    00783            fabs( m_fZ - in_cVec3.GetZ() ) < ::fabs(in_fEpsilon) );
    00784 }
    00785
    00786
    00787 SICPPSDK_INLINE bool CVector3f::Equals(const CVector3f& in_vec3)const
    00788 {
    00789     return (this == &in_vec3) ? true :
    00790         ( ( m_fX == in_vec3.GetX() ) &&
    00791           ( m_fY == in_vec3.GetY() ) &&
    00792           ( m_fZ == in_vec3.GetZ() ) );
    00793 }
    00794
    00795 SICPPSDK_INLINE CVector3f& CVector3f::ScaleAddInPlace
    00796 (
    00797     const float in_fScalingFactor,
    00798     const CVector3f& in_vec3
    00799 )
    00800 {
    00801     ScaleInPlace(in_fScalingFactor);
    00802     return AddInPlace(in_vec3);
    00803 }
    00804
    00805
    00806 SICPPSDK_INLINE CVector3f& CVector3f::ScaleAdd
    00807 (
    00808     const float in_fScalingFactor,
    00809     const CVector3f& in_vec3A,
    00810     const CVector3f& in_vec3B
    00811 )
    00812 {
    00813     Scale(in_fScalingFactor, in_vec3A);
    00814     return AddInPlace(in_vec3B);
    00815 }
    00816
    00817 SICPPSDK_INLINE CVector3f& CVector3f::ScaleInPlace(const float in_fScalingFactor)
    00818 {
    00819     m_fX *= in_fScalingFactor;
    00820     m_fY *= in_fScalingFactor;
    00821     m_fZ *= in_fScalingFactor;
    00822     return (*this);
    00823 }
    00824
    00825 SICPPSDK_INLINE CVector3f& CVector3f::Scale
    00826 (
    00827     const float in_fScalingFactor,
    00828     const CVector3f& in_vec3
    00829 )
    00830 {
    00831     m_fX = in_vec3.GetX() * in_fScalingFactor;
    00832     m_fY = in_vec3.GetY() * in_fScalingFactor;
    00833     m_fZ = in_vec3.GetZ() * in_fScalingFactor;
    00834     return (*this);
    00835 }
    00836
    00837 SICPPSDK_INLINE CVector3f& CVector3f::NegateInPlace()
    00838 {
    00839     m_fX = -m_fX;
    00840     m_fY = -m_fY;
    00841     m_fZ = -m_fZ;
    00842     return (*this);
    00843 }
    00844
    00845 SICPPSDK_INLINE CVector3f& CVector3f::Negate(const CVector3f& in_vec3 )
    00846 {
    00847     m_fX = -in_vec3.GetX();
    00848     m_fY = -in_vec3.GetY();
    00849     m_fZ = -in_vec3.GetZ();
    00850     return (*this);
    00851 }
    00852
    00853 SICPPSDK_INLINE CVector3f& CVector3f::SubInPlace(const CVector3f& in_vec3)
    00854 {
    00855     m_fX -= in_vec3.GetX();
    00856     m_fY -= in_vec3.GetY();
    00857     m_fZ -= in_vec3.GetZ();
    00858     return (*this);
    00859 }
    00860
    00861 SICPPSDK_INLINE CVector3f& CVector3f::Sub
    00862 (
    00863     const CVector3f& in_vec3A,
    00864     const CVector3f& in_vec3B
    00865 )
    00866 {
    00867     m_fX = in_vec3A.GetX() - in_vec3B.GetX();
    00868     m_fY = in_vec3A.GetY() - in_vec3B.GetY();
    00869     m_fZ = in_vec3A.GetZ() - in_vec3B.GetZ();
    00870     return (*this);
    00871 }
    00872
    00873 SICPPSDK_INLINE CVector3f& CVector3f::AddInPlace(const CVector3f& in_vec3)
    00874 {
    00875     m_fX += in_vec3.GetX();
    00876     m_fY += in_vec3.GetY();
    00877     m_fZ += in_vec3.GetZ();
    00878     return (*this);
    00879 }
    00880
    00881 SICPPSDK_INLINE CVector3f& CVector3f::Add
    00882 (
    00883     const CVector3f& in_vec3A,
    00884     const CVector3f& in_vec3B
    00885 )
    00886 {
    00887     m_fX = in_vec3A.GetX() + in_vec3B.GetX();
    00888     m_fY = in_vec3A.GetY() + in_vec3B.GetY();
    00889     m_fZ = in_vec3A.GetZ() + in_vec3B.GetZ();
    00890     return (*this);
    00891 }
    00892
    00893 SICPPSDK_INLINE void CVector3f::Get(float& io_rfX, float& io_rfY, float& io_rfZ)const
    00894 {
    00895     io_rfX = m_fX;
    00896     io_rfY = m_fY;
    00897     io_rfZ = m_fZ;
    00898 }
    00899
    00900 SICPPSDK_INLINE CVector3f& CVector3f::Set(const float in_fX, const float in_fY, const float in_fZ)
    00901 {
    00902     m_fX = in_fX;
    00903     m_fY = in_fY;
    00904     m_fZ = in_fZ;
    00905     return (*this);
    00906 }
    00907
    00908 SICPPSDK_INLINE float CVector3f::GetZ()const
    00909 {
    00910     return m_fZ;
    00911 }
    00912
    00913 SICPPSDK_INLINE CVector3f&  CVector3f::PutZ(const float in_fZ)
    00914 {
    00915     m_fZ = in_fZ;
    00916     return (*this);
    00917 }
    00918
    00919 SICPPSDK_INLINE float CVector3f::GetY()const
    00920 {
    00921     return m_fY;
    00922 }
    00923
    00924 SICPPSDK_INLINE CVector3f& CVector3f::PutY(const float in_fY)
    00925 {
    00926     m_fY = in_fY;
    00927     return (*this);
    00928 }
    00929
    00930 SICPPSDK_INLINE float CVector3f::GetX()const
    00931 {
    00932     return m_fX;
    00933 }
    00934
    00935 SICPPSDK_INLINE CVector3f& CVector3f::PutX(const float in_fX)
    00936 {
    00937     m_fX = in_fX;
    00938     return (*this);
    00939 }
    00940
    00941 SICPPSDK_INLINE CStatus CVector3f::NormalizeInPlace()
    00942 {
    00943     float rLen = GetLength();
    00944
    00945     if ( rLen > MicroEPS )
    00946     {
    00947         m_fX /= rLen ;
    00948         m_fY /= rLen ;
    00949         m_fZ /= rLen ;
    00950         return CStatus::OK;
    00951     }
    00952
    00953     return CStatus::Fail;
    00954 }
    00955
    00956 SICPPSDK_INLINE CStatus CVector3f::Normalize(const CVector3f& in_vec3)
    00957 {
    00958     float rLen = in_vec3.GetLength();
    00959
    00960     if ( rLen > MicroEPS )
    00961     {
    00962         m_fX = in_vec3.GetX() / rLen ;
    00963         m_fY = in_vec3.GetY() / rLen ;
    00964         m_fZ = in_vec3.GetZ() / rLen ;
    00965         return CStatus::OK;
    00966     }
    00967
    00968     return CStatus::Fail;
    00969 }
    00970
    00971 SICPPSDK_INLINE float CVector3f::GetAngle( const CVector3f& in_vec3 ) const
    00972 {
    00973     float fCosAngle, fLen;
    00974
    00975     fLen = GetLength();
    00976     fLen *= in_vec3.GetLength();
    00977     if( fLen < MicroEPS )
    00978     {
    00979         return( 0.0 );
    00980     }
    00981     else
    00982     {
    00983         fCosAngle = ( m_fX*in_vec3.GetX() + m_fY*in_vec3.GetY() + m_fZ*in_vec3.GetZ() ) / fLen;
    00984         LimitValue( fCosAngle, -1.0, 1.0 );
    00985         return( acos( fCosAngle ) );
    00986     }
    00987     return( 0.0 );
    00988 }
    00989
    00990 SICPPSDK_INLINE CVector3f& CVector3f::AbsoluteInPlace()
    00991 {
    00992     float l_fX, l_fY, l_fZ;
    00993     Get(l_fX, l_fY, l_fZ);
    00994     Set(::fabs(l_fX), ::fabs(l_fY), ::fabs(l_fZ));
    00995     return (*this);
    00996 }
    00997
    00998 SICPPSDK_INLINE CVector3f& CVector3f::Absolute(const CVector3f& in_rCVec3)
    00999 {
    01000     float l_fX, l_fY, l_fZ;
    01001     in_rCVec3.Get(l_fX, l_fY, l_fZ);
    01002     m_fX = ::fabs(l_fX);
    01003     m_fY = ::fabs(l_fY);
    01004     m_fZ = ::fabs(l_fZ);
    01005
    01006     return (*this);
    01007 }
    01008
    01009 SICPPSDK_INLINE CVector3f& CVector3f::ClampInPlace(const float in_fMin, const float in_fMax)
    01010 {
    01011     float l_fX, l_fY, l_fZ;
    01012
    01013     Get( l_fX, l_fY, l_fZ );
    01014
    01015     LimitValue( l_fX, in_fMin, in_fMax );
    01016     LimitValue( l_fY, in_fMin, in_fMax );
    01017     LimitValue( l_fZ, in_fMin, in_fMax );
    01018
    01019     Set( l_fX, l_fY, l_fZ );
    01020
    01021     return (*this);
    01022 }
    01023
    01024 };
    01025 };
    01026
    01027 #endif // __XSIVECTOR3F_H__