K3dVector2.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 "K3dVector2.h" 

// Konstruktor t�y 2d vektoru, kter resetuje vektor
K3dVector2::K3dVector2()
{
}



//      Constructor set vector from array
K3dVector2::K3dVector2( const float vector[2] )
{
        m_afVector[0] = vector[0];      // Set x
        m_afVector[1] = vector[1];      // Set y
}



//      Constructor set vector from x, y values
K3dVector2::K3dVector2( float x, float y )
{
        m_afVector[0] = x;      // Set x
        m_afVector[1] = y;      // Set y
}



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



// Assignment operator
K3dVector2& K3dVector2::operator= (const K3dVector2& rkV)
{

        for(int i=0; i<2; i++)
        {
                m_afVector[i] = rkV.m_afVector[i];
        }

        return *this;
}



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



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

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

        return K3dVector2(afValue);                     //      Return slave array

}



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

        return *this;
}



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

        return *this;
}



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

        return *this;
}



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

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



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

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



K3dVector2 K3dVector2::operator- () 
{
        K3dVector2 kNeg((float)0, (float)0);
        for (int i = 0; i < 2; i++)
                kNeg.m_afVector[i] = -m_afVector[i];
        return kNeg;
}





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

        }

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



// Overloaded operator*= allows multiply two vectors 
K3dVector2 K3dVector2::operator*=( const K3dVector2 &rkVector )
{
        for (int i=0; i<2; 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
K3dVector2 K3dVector2::operator*=( float fScalar )                      
{
        for (int i=0; i<2; i++)                                 // Go through x, y, z values
        {
                m_afVector[i] *= fScalar;       // Hold to slave array
        }

        return *this;
}



// Overloaded operator/= allows divide two vectors 
K3dVector2 K3dVector2::operator/=( const K3dVector2 &rkVector )
{
        for (int i=0; i<2; 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 divide vector and float value
K3dVector2 K3dVector2::operator/=( float fScalar )
{
        float fInvScalar;

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


        return *this;
}




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

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

        return K3dVector2(af);
}



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


        for (int i=0; i<2; 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;


}



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

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



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

        for (int i = 0; i < 2; 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;
}



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

---