K3dVector4.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2007 by Jan Koci   *
 *   honza.koci@email.cz   *
 *   http://kengine.sourceforge.net/tutorial/
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#pragma once

#include <iostream>
#include <cmath>

#include "../System/K3dString.h"

// 4D vector class
class K3dVector4:
                        public K3dString
{
                //      4d vector x,y,z,w
                float m_afVector[4];
        public:


                //      Reset constructor (0, 0, 0, 0)
                K3dVector4();
                // Constructor set private vector
                K3dVector4 ( const K3dVector4& rkV );
                //      Constructor set vector from array
                K3dVector4 ( const float afVector[4] );
                //      Constructor set vector from x, y, z,w values
                K3dVector4 ( const float fX, const float fY, const float fZ, const float  fW );
                // Constructor to set vector from unsigned char array
                K3dVector4 ( const unsigned char aucVector[4] );
                ~K3dVector4();

                // Coordinate access

                // Get vector array
                float *GetVector();
                // Overloaded operator[] allows set vector arrays
                float &operator[] ( int index ) ;
                // Set vector from another vector
                void Set ( K3dVector4 &_rkVec );
                // Set vector from      array values
                void Set ( float _rkVector[4] );
                // Set vector from      (x, y, z) values
                void Set ( const float fX, const float fY, const float fZ, const float fW );
                // Get scalar by index
                float GetScalar ( const int index );
                // Set value by index
                void SetScalar ( const float fScalar, const int index );

                // Assignment operator
                K3dVector4& operator= ( K3dVector4& rkV );

                // Comparison operators
                bool operator== ( K3dVector4& rkV );
                bool operator!= ( K3dVector4& rkV );
                bool operator< ( K3dVector4& rkV );
                bool operator<= ( K3dVector4& rkV );
                bool operator> ( K3dVector4& rkV );
                bool operator>= ( K3dVector4& rkV );
                // Compare arrays for comparison operators
                int CompareArrays ( K3dVector4& rkV );


                // Arithmetic operations

                // Overloaded operator+
                K3dVector4 operator+ ( K3dVector4& rkV );
                // Overloaded operator+ allows add vector and float value
                K3dVector4 operator+ ( float fScalar );
                // Overloaded operator- allows subtract two vectors
                K3dVector4 operator- ( K3dVector4 &rkVector );
                // Overloaded operator- allows add vector and float value
                K3dVector4 operator- ( float fScalar );
                K3dVector4 operator- ();
                // Overloaded operator* allows multiply two vectors
                K3dVector4 operator* ( K3dVector4 &rkVector );
                // Overloaded operator* allows multiply vector and float value
                K3dVector4 operator* ( float fScalar );
                // Overloaded operator* allows divide two vectors
                K3dVector4 operator/ ( K3dVector4 &rkVector );
                // Overloaded operator* allows divide two vectors
                K3dVector4 operator/ ( float fScalar );


                // Arithmetic updates

                // Overloaded operator+=
                K3dVector4& operator+= ( const K3dVector4 &rkVector );
                // Overloaded scalar operator+=
                K3dVector4& operator+= ( float fScalar );
                // Overloaded operator-=
                K3dVector4& operator-= ( const K3dVector4 &rkVector );
                // Overloaded scalar operator-=
                K3dVector4& operator-= ( float fScalar );
                // Overloaded operator*= allows multiply two vectors
                K3dVector4 operator*= ( const K3dVector4 &rkVector );
                // Overloaded operator*= allows multiply vector and float value
                K3dVector4 operator*= ( float fScalar );
                // Overloaded operator/= allows divide two vectors
                K3dVector4 operator/= ( const K3dVector4 &rkVector );
                // Overloaded operator/= allows divide vector and float value
                K3dVector4 operator/= ( float fScalar );


                // Functions
                // Calc square of vector
                K3dVector4 Sqr();
                //      Reset vector to (0, 0, 0, 0 )
                void Reset();
                // Calculate vector length.
                float Length();
                // Calc square vector length
                float SquaredLength ();
                //      Normalize vector
                void Normalize();
                // Invert vector
                void Invert();
                // Calculate dot product between two vectors
                float Dot ( const K3dVector4 &_rkV1, const K3dVector4 &_rkkV2 );
                // Calculate dot product between two vectors
                float Dot ( const K3dVector4 &_rkV );


};





// Comparison ==
inline bool K3dVector4::operator== ( K3dVector4& rkV )
{
        return memcmp ( m_afVector, rkV.m_afVector, 4*sizeof ( float ) ) == 0;
}



inline bool K3dVector4::operator!= ( K3dVector4& rkV )
{
        return memcmp ( m_afVector, rkV.m_afVector, 4*sizeof ( float ) ) != 0;
}



inline bool K3dVector4::operator< ( K3dVector4& rkV )
{
        return CompareArrays ( rkV ) < 0;
}



inline bool K3dVector4::operator<= ( K3dVector4& rkV )
{
        return CompareArrays ( rkV ) <= 0;
}



inline bool K3dVector4::operator> ( K3dVector4& rkV )
{
        return CompareArrays ( rkV ) > 0;
}



inline bool K3dVector4::operator>= ( K3dVector4& rkV )
{
        return CompareArrays ( rkV ) >= 0;
}




// Overloaded operator/= allows divide vector and float value
inline K3dVector4 K3dVector4::operator/= ( float fScalar )
{
        float fInvScalar;

        if ( fScalar )
        {
                fInvScalar = 1.0f / fScalar;
                for ( int i=0; i<4; i++ )
                {
                        m_afVector[i] *= fInvScalar;
                }
        }
        else
        {
                this->Set ( 0,0,0,0 );
        }


        return *this;
}


// Overloaded operator* allows divide vector by scalar
inline K3dVector4 K3dVector4::operator/ ( float fScalar )
{
        K3dVector4 kV ( 0,0,0,0 );

        if ( fScalar )
        {
                for ( int i=0; i<4; i++ )                                               // Go through x, y, z values
                {
                        kV.m_afVector[i] = m_afVector[i] / fScalar;
                }
        }
        return kV;
}



// Overloaded operator[] allows set vector arrays
inline float &K3dVector4::operator[] ( int i )
{
        if ( ! ( 0 <= i ) && ( i < 4 ) )
        {
                cerr  << "Error :: K3dVector4::operator[] -- wrong index " << i << endl;
                return m_afVector[0];
                //CDebug::InfoMsg("K3dVector4::operator[]() -- error index", i);
        }
        return m_afVector[i];
}





// Get vector pointer
inline float *K3dVector4::GetVector()
{
        return m_afVector;
}



// Get scalar by index
inline float K3dVector4::GetScalar ( const int i )
{
        if ( ! ( 0 <= i ) && ( i < 4 ) )
        {
                cerr  << "Error :: K3dVector4::GetScalar() -- wrong index " << i << endl;
                return ( float ) 0;
                //CDebug::InfoMsg("K3dVector4::operator[]() -- error index", i);
        }
        return m_afVector[i];
}



// Set scalar by index
inline void K3dVector4::SetScalar ( const float fScalar, const int i )
{
        if ( ! ( 0 <= i ) && ( i < 4 ) )
        {
                cerr  << "Error :: K3dVector4::SetScalar() -- wrong index " << i << endl;
                return;
                //CDebug::InfoMsg("K3dVector4::operator[]() -- error index", i);
        }
        m_afVector[i] = fScalar;
}



// Invert vector
inline void K3dVector4::Invert()
{
        m_afVector[0] = -m_afVector[0];
        m_afVector[1] = -m_afVector[1];
        m_afVector[2] = -m_afVector[2];
        m_afVector[3] = -m_afVector[3];

}



// Calculate dot product between two vectors
inline float K3dVector4::Dot ( const K3dVector4 &_rkV1, const K3dVector4 &_rkV2 )
{
        float fX,fY, fZ, fW, fResult;

        fX = _rkV1.m_afVector[0] * _rkV2.m_afVector[0];
        fY = _rkV1.m_afVector[1] * _rkV2.m_afVector[1];
        fZ = _rkV1.m_afVector[2] * _rkV2.m_afVector[2];
        fW = _rkV1.m_afVector[3] * _rkV2.m_afVector[3];

        fResult = fX + fY + fZ + fW;
        return fResult;
}




// Calculate dot product between two vectors
inline float K3dVector4::Dot ( const K3dVector4 &_rkVector )
{

        float fX,fY, fZ, fW, fResult;

        fX = m_afVector[0] * _rkVector.m_afVector[0];
        fY = m_afVector[1] * _rkVector.m_afVector[1];
        fZ = m_afVector[2] * _rkVector.m_afVector[2];
        fW = m_afVector[3] * _rkVector.m_afVector[3];

        fResult = fX + fY + fZ + fW;
        return fResult;

}



//      Reset vector to (0, 0, 0, 0)
inline void K3dVector4::Reset()
{
        m_afVector[0] = m_afVector[1] = m_afVector[2] = m_afVector[3] = 0;
}



// Set vector from another vector
inline void K3dVector4::Set ( K3dVector4 &_rkVec )
{
        m_afVector[0] = _rkVec.m_afVector[0];
        m_afVector[1] = _rkVec.m_afVector[1];
        m_afVector[2] = _rkVec.m_afVector[2];
        m_afVector[3] = _rkVec.m_afVector[3];
}



// Set x,y,z coordinates from array
inline void K3dVector4::Set ( float vector[4] )
{
        m_afVector[0] = vector[0];
        m_afVector[1] = vector[1];
        m_afVector[2] = vector[2];
        m_afVector[3] = vector[3];
}



// Set vector from      (x, y, z, w) values
inline void K3dVector4::Set ( const float fX, const float fY, const float fZ, const float fW )
{
        m_afVector[0] = fX;
        m_afVector[1] = fY;
        m_afVector[2] = fZ;
        m_afVector[3] = fW;
}




//      Normalize vector
inline void K3dVector4::Normalize()
{

        float fLength0, fLength1;

        // Calculate vector lenght
        fLength0 = Length();

        if ( fLength0 )
        {
                fLength1 = 1.0f/fLength0;
                m_afVector[0] *= fLength1;
                m_afVector[1] *= fLength1;
                m_afVector[2] *= fLength1;
                m_afVector[3] *= fLength1;
        }
}



// Calculate vector length
inline float K3dVector4::Length()
{
        return ( float ) sqrt ( m_afVector[0] * m_afVector[0] + m_afVector[1] * m_afVector[1] + m_afVector[2] * m_afVector[2] + m_afVector[3] * m_afVector[3] );
}



// Calc square vector length
inline float K3dVector4::SquaredLength ()
{
        float fSqrLen = 0.0f;
        for ( int i = 0; i < 4; i++ )
                fSqrLen += m_afVector[i]*m_afVector[i];
        return fSqrLen;
}



// Calc square of vector
inline K3dVector4 K3dVector4::Sqr()
{
        K3dVector4 kV;

        kV = *this;

        kV *= kV;

        return kV;
}

---