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

K3dVector3::K3dVector3()
{
        Reset();
}

K3dVector3::K3dVector3 ( const K3dVector3& _rkV )
{
        for ( int i=0; i<3; i++ )
        {
                m_afVector[i] = _rkV.m_afVector[i];
        }
}

K3dVector3::K3dVector3 ( const float afVector[3] )
{
        m_afVector[0] = afVector[0];    // Set x
        m_afVector[1] = afVector[1];    // Set y
        m_afVector[2] = afVector[2];    // Set z
}

K3dVector3::K3dVector3 ( const unsigned char aucVector[3] )
{
        m_afVector[0] = ( float ) aucVector[0]; // Set x
        m_afVector[1] = ( float ) aucVector[1]; // Set y
        m_afVector[2] = ( float ) aucVector[2]; // Set z
}

K3dVector3::K3dVector3 ( float x, float y, float z )
{
        m_afVector[0] = x;      // Set x
        m_afVector[1] = y;      // Set y
        m_afVector[2] = z;      // Set z
}

K3dVector3::~K3dVector3()
{
        Reset();
}

void K3dVector3::Reset()
{
        m_afVector[0] = m_afVector[1] = m_afVector[2] = ( float ) 0;
}

K3dVector3& K3dVector3::operator= ( const K3dVector3& _rkV )
{
        for ( int i=0; i<3; i++ )
        {
                m_afVector[i] = _rkV.m_afVector[i];
        }
        return *this;
}

K3dVector3 K3dVector3::operator+ ( const K3dVector3& _rkV ) const
{
        K3dVector3 kSum;
        for ( int i = 0; i < 3; i++ )
                kSum.m_afVector[i] = m_afVector[i] + _rkV.m_afVector[i];
        return kSum;
}

K3dVector3 K3dVector3::operator+ ( const float fScalar ) const
{

        float afValue[3];
        for ( int i=0; i<3; i++ )
        {
                afValue[i] = m_afVector[i] + fScalar;
        }
        return K3dVector3 ( afValue );
}

K3dVector3& K3dVector3::operator+= ( const K3dVector3 &_rkVector )
{
        for ( int i=0; i<3; i++ )
        {
                this->m_afVector[i] += _rkVector.m_afVector[i];
        }

        return *this;
}

K3dVector3& K3dVector3::operator+= ( const float fScalar )
{
        for ( int i=0; i<3; i++ )
        {
                this->m_afVector[i] += fScalar;
        }

        return *this;
}

K3dVector3& K3dVector3::operator-= ( const float fScalar )
{
        for ( int i=0; i<3; i++ )
        {
                this->m_afVector[i] -= fScalar;
        }

        return *this;
}

K3dVector3& K3dVector3::operator-= ( const K3dVector3 &_rkVector )
{
        m_afVector[0] -= _rkVector.m_afVector[0];
        m_afVector[1] -= _rkVector.m_afVector[1];
        m_afVector[2] -= _rkVector.m_afVector[2];
        return *this;
}

K3dVector3 K3dVector3::operator- ( const K3dVector3 &_rkVector ) const
{
        float f_value[3];
        for ( int i=0; i<3; i++ )
        {
                f_value[i] = m_afVector[i] - _rkVector[i];
        }

        return K3dVector3 ( f_value );
}

K3dVector3 K3dVector3::operator- ( const float f ) const
{
        float afValue[3];
        for ( int i=0; i<3; i++ )
        {
                afValue[i] = m_afVector[i] - f;
        }

        return K3dVector3 ( afValue );
}

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

K3dVector3 K3dVector3::operator* ( const float num ) const
{
        float f_value[3];
        for ( int i=0; i<3; i++ )
        {
                f_value[i] = m_afVector[i] * num;

        }
        return K3dVector3 ( f_value );
}

K3dVector3 K3dVector3::operator*= ( const K3dVector3 &_rkVector )
{
        for ( int i=0; i<3; i++ )
        {
                m_afVector[i] *= _rkVector.m_afVector[i];
        }
        return *this;
}

K3dVector3 K3dVector3::operator*= ( const float fScalar )
{
        for ( int i=0; i<3; i++ )
        {
                m_afVector[i] *= fScalar;
        }
        return *this;
}

K3dVector3 K3dVector3::operator/= ( const K3dVector3 &_rkVector )
{
        for ( int i=0; i<3; i++ )
        {
                if ( _rkVector.m_afVector[i] )
                {
                        m_afVector[i] /= _rkVector.m_afVector[i];
                }
                else
                {
                        m_afVector[i] = 0;
                }
        }
        return *this;
}

K3dVector3 K3dVector3::operator* ( const K3dVector3 &_rkVector ) const
{
        float af[3];
        for ( int i=0; i<3; i++ )
        {
                af[i] = m_afVector[i] * _rkVector.m_afVector[i];
        }
        return K3dVector3 ( af );
}

K3dVector3 K3dVector3::operator/ ( const K3dVector3 &_rkVector ) const
{
        K3dVector3 kV ( 0,0,0 );

        for ( int i=0; i<3; i++ )
        {
                if ( _rkVector.m_afVector[i] )
                {
                        kV.m_afVector[i] = m_afVector[i] / _rkVector.m_afVector[i];
                }
        }
        return kV;
}

K3dVector3 K3dVector3::operator/ ( const float fScalar ) const
{
        K3dVector3 kV ( 0,0,0 );
        float fInvScalar;
        if ( fScalar )
        {
                fInvScalar = 1.0f / fScalar;
                for ( int i=0; i<3; i++ )
                {
                        kV.m_afVector[i] = m_afVector[i] * fInvScalar;
                }
        }
        return kV;
}

int K3dVector3::CompareArrays ( const K3dVector3& _rkV ) const
{
        unsigned int uiTest0;
        unsigned int uiTest1;

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

bool K3dVector3::operator== ( const K3dVector3& _rkV ) const
{
        // Round vector scalars for prevent rounding errors
        if((K3dMath::EqualRange ( GetX(), _rkV.GetX(), K_EQUAL_RANGE )) == false)
        {
                return false;
        }
        if((K3dMath::EqualRange ( GetY(), _rkV.GetY(), K_EQUAL_RANGE )) == false)
        {
                return false;
        }
        if((K3dMath::EqualRange ( GetZ(), _rkV.GetZ(), K_EQUAL_RANGE )) == false)
        {
                return false;
        }
        return true;
}

bool K3dVector3::operator== ( const K3dVector3& _rkV )
{
        // Round vector scalars for prevent rounding errors
        if((K3dMath::EqualRange ( GetX(), _rkV.GetX(), K_EQUAL_RANGE )) == false)
        {
                return false;
        }
        if((K3dMath::EqualRange ( GetY(), _rkV.GetY(), K_EQUAL_RANGE )) == false)
        {
                return false;
        }
        if((K3dMath::EqualRange ( GetZ(), _rkV.GetZ(), K_EQUAL_RANGE )) == false)
        {
                return false;
        }
        return true;
}

---