K3dVector4.cpp

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.             *
 ***************************************************************************/

#include "K3dVector4.h"


K3dVector4::K3dVector4()
{
}

// Constructor set private vector
K3dVector4::K3dVector4(const K3dVector4& rkV)
{
        for(int i=0; i<4; i++)
        {
                m_afVector[i] = rkV.m_afVector[i];
        }
}

//      Constructor set vector from array
K3dVector4::K3dVector4( const float afVector[4] )
{
        m_afVector[0] = afVector[0];    // Set x
        m_afVector[1] = afVector[1];    // Set y
        m_afVector[2] = afVector[2];    // Set z 
        m_afVector[3] = afVector[3];    // Set w 
}



// Constructor to set vector from unsigned char array
K3dVector4::K3dVector4(const unsigned char aucVector[4])
{
        m_afVector[0] = (float) aucVector[0];   // Set x
        m_afVector[1] = (float) aucVector[1];   // Set y
        m_afVector[2] = (float) aucVector[2];   // Set z 
        m_afVector[3] = (float) aucVector[3];   // Set w 
}



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



// Descructor
K3dVector4::~K3dVector4()
{
}



// Assignment operator
K3dVector4& K3dVector4::operator= ( K3dVector4& rkV)
{
        for(int i=0; i<4; i++)
        {
                m_afVector[i] = rkV.m_afVector[i];
        }
        return *this;
}



// Overloaded operator+ allows add two vectors
K3dVector4 K3dVector4::operator+(K3dVector4& rkV )               
{
        K3dVector4 kSum;
        for (int i = 0; i < 4; i++)
                kSum.m_afVector[i] = m_afVector[i] + rkV.m_afVector[i];
        return kSum;
}



// Overloaded operator+ allows add vector and float value
K3dVector4 K3dVector4::operator+( float fScalar )        
{

        float afValue[4];                                               // Slave array
        for (int i=0; i<4; i++)                                 // Go through x, y, z values
        {
                afValue[i] = m_afVector[i] + fScalar;   // Hold to slave array
        }

        return K3dVector4(afValue);                     //      Return slave array

}



// Overloaded operator+=
K3dVector4& K3dVector4::operator+=(const K3dVector4 &rkVector)
{
        for (int i=0; i<4; i++)                                 // Go through x, y, z values
        {
                this->m_afVector[i] += rkVector.m_afVector[i]; 
        }

        return *this;
}



// Overloaded scalar operator+=
K3dVector4& K3dVector4::operator+=(float fScalar )
{
        for (int i=0; i<4; i++)                                 
        {
                this->m_afVector[i] += fScalar; 
        }

        return *this;
}



// Overloaded scalar operator-=
K3dVector4& K3dVector4::operator-=(float fScalar )
{
        for (int i=0; i<4; i++)                                 
        {
                this->m_afVector[i] -= fScalar; 
        }

        return *this;
}



// Overloaded operator-=
K3dVector4& K3dVector4::operator-=(const K3dVector4 &rkVector)
{
        for (int i=0; i<4; i++)                                 
        {
                this->m_afVector[i] = this->m_afVector[i] - rkVector.m_afVector[i]; 
        }

        return *this;
}



// Overloaded operator- allows subtract two vectors
K3dVector4 K3dVector4::operator-(K3dVector4 &rkVector )         
{
        float f_value[4];                                       
        for (int i=0; i<4; i++)                                 
        {
                f_value[i] = m_afVector[i] - rkVector[i];       // Hold to slave array
        }

        return K3dVector4(f_value);                             //      Return slave array
}



// Overloaded operator- allows add vector and float value
K3dVector4 K3dVector4::operator-( float f )              
{
        float afValue[4];                                               // Slave array
        for (int i=0; i<4; i++)                                 // Go through x, y, z values
        {
                afValue[i] = m_afVector[i] - f; // Hold to slave array
        }

        return K3dVector4(afValue);                     //      Return slave array
}



K3dVector4 K3dVector4::operator- ()
{
        K3dVector4 kNeg;
        for (int i = 0; i < 4; i++)
                kNeg.m_afVector[i] = -m_afVector[i];
        return kNeg;
}



// Overloaded operator* allows multiply vector and float value
K3dVector4 K3dVector4::operator*( float num )           
{
        float f_value[4];                                               // Slave array
        for (int i=0; i<4; i++)                                 // Go through x, y, z values
        {
                f_value[i] = m_afVector[i] * num;       // Hold to slave array

        }

        return K3dVector4(f_value);                             // Return slave array
}



// Overloaded operator*= allows multiply two vectors 
K3dVector4 K3dVector4::operator*=( const K3dVector4 &rkVector )
{
        for (int i=0; i<4; i++)                                 // Go through x, y, z values
        {
                m_afVector[i] *= rkVector.m_afVector[i];        // Hold to slave array
        }

        return *this;
}



// Overloaded operator*= allows multiply vector and float value
K3dVector4 K3dVector4::operator*=( float fScalar )                      
{
        for (int i=0; i<4; i++)                                 // Go through x, y, z values
        {
                m_afVector[i] *= fScalar;       // Hold to slave array
        }

        return *this;
}



// Overloaded operator/= allows divide two vectors 
K3dVector4 K3dVector4::operator/=( const K3dVector4 &rkVector )
{
        for (int i=0; i<4; i++)                                 // Go through x, y, z values
        {
                if(rkVector.m_afVector[i])
                {
                        m_afVector[i] /= rkVector.m_afVector[i];        // Hold to slave array
                }
                else
                {
                        m_afVector[i] = 0;
                }
        }

        return *this;
}


// Overloaded operator* allows multiply two vectors
K3dVector4 K3dVector4::operator*( K3dVector4 &rkVector )                        
{
        float af[4];

        for (int i=0; i<4; i++)                                 // Go through x, y, z values
        {
                af[i] = m_afVector[i] * rkVector.m_afVector[i];
        }

        return K3dVector4(af);
}



// Overloaded operator* allows divide two vectors
K3dVector4 K3dVector4::operator/( K3dVector4 &rkVector  )
{
        K3dVector4 kV(0,0,0,0);


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

        return kV;


}



// Compare arrays for comparison operators
int K3dVector4::CompareArrays(K3dVector4& rkV)
{
        unsigned int uiTest0;
        unsigned int uiTest1;

        for (int i = 0; i < 4; i++)
        {
                uiTest0 = *(unsigned int*)&m_afVector[i];
                uiTest1 = *(unsigned int*)&rkV.m_afVector[i];
                if ( uiTest0 < uiTest1 )
                        return -1;
                if ( uiTest0 > uiTest1 )
                        return +1;
        }
        return 0;
}

---