K3dVector3.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 <fstream>

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


using namespace std;

// 3D vector class
class K3dVector3
{
                float m_afVector[3];    
        public:
                K3dVector3();
                K3dVector3 ( const K3dVector3& _rkV );
                K3dVector3 ( const float afVector[3] );
                K3dVector3 ( float x, float y, float z );
                K3dVector3 ( const unsigned char aucVector[3] );
                ~K3dVector3();

                // Coordinate access

                // Get vector array
                float *GetVectorArray()
                {
                        return m_afVector;
                }
                const float *GetVectorArray() const
                {
                        return m_afVector;
                }
                K3dVector3 &GetVector()
                {
                        return *this;
                }

                const K3dVector3 &GetVector() const
                {
                        return *this;
                }

                void Set ( K3dVector3 &_rV );
                void Set ( float vector[3] );
                void Set ( float x, float y, float z );
                void SetX ( const float fX );
                void SetY ( const float fY );
                void SetZ ( const float fZ );
                float &GetX()
                {
                        return m_afVector[0];
                }
                const float &GetX() const
                {
                        return m_afVector[0];
                }
                float &GetY()
                {
                        return m_afVector[1];
                }
                const float &GetY() const
                {
                        return m_afVector[1];
                }
                float &GetZ()
                {
                        return m_afVector[2];
                }
                const float &GetZ() const
                {
                        return m_afVector[2];
                }
                float GetScalar ( const int index );
                void SetScalar ( const float fScalar, const int index );
                void Reset();

                // Operators

                float &operator[] ( int index ) ;
                const float &operator[] ( int index ) const;

                // Assignment operator
                K3dVector3& operator= ( const K3dVector3& _rkV );

                // Comparison operators
                bool operator== ( const K3dVector3& _rkV ) const;
                bool operator== ( const K3dVector3& _rkV );
                bool operator!= ( const K3dVector3& _rkV ) const;
                bool operator< ( const K3dVector3& _rkV ) const;
                bool operator<= ( const K3dVector3& _rkV ) const;
                bool operator> ( const K3dVector3& _rkV ) const;
                bool operator>= ( const K3dVector3& _rkV ) const;
                // Compare arrays for comparison operators
                int CompareArrays ( const K3dVector3& _rkV ) const;


                // Arithmetic operations

                // Overloaded operator+
                K3dVector3 operator+ ( const K3dVector3& _rkV ) const;
                K3dVector3 operator+ ( const float fScalar ) const;
                K3dVector3 operator- ( const K3dVector3 &_rkVector ) const;
                K3dVector3 operator- ( const float fScalar ) const;
                K3dVector3 operator- () const;
                K3dVector3 operator* ( const K3dVector3 &_rkVector ) const;
                K3dVector3 operator* ( const float fScalar ) const;
                K3dVector3 operator/ ( const K3dVector3 &_rkVector ) const;
                K3dVector3 operator/ ( const float fScalar ) const;

                // Arithmetic updates

                K3dVector3& operator+= ( const K3dVector3 &_rkVector );
                K3dVector3& operator+= ( const float fScalar );
                K3dVector3& operator-= ( const K3dVector3 &_rkVector );
                K3dVector3& operator-= ( const float fScalar );
                K3dVector3 operator*= ( const K3dVector3 &_rkVector );
                K3dVector3 operator*= ( const float fScalar );
                K3dVector3 operator/= ( const K3dVector3 &_rkVector );
                K3dVector3 operator/= ( const float fScalar );
};

inline bool K3dVector3::operator!= ( const K3dVector3& _rkV ) const
{
        return memcmp ( m_afVector, _rkV.m_afVector, 3*sizeof ( float ) ) != 0;
}

inline bool K3dVector3::operator< ( const K3dVector3& _rkV ) const
{
        return CompareArrays ( _rkV ) < 0;
}

inline bool K3dVector3::operator<= ( const K3dVector3& _rkV ) const
{
        return CompareArrays ( _rkV ) <= 0;
}

inline bool K3dVector3::operator> ( const K3dVector3& _rkV ) const
{
        return CompareArrays ( _rkV ) > 0;
}

inline bool K3dVector3::operator>= ( const K3dVector3& _rkV ) const
{
        return CompareArrays ( _rkV ) >= 0;
}

inline K3dVector3 K3dVector3::operator/= ( float fScalar )
{
        float fInvScalar;

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

inline float &K3dVector3::operator[] ( int i )
{
        if ( ! ( 0 <= i ) && ( i < 3 ) )
        {
                cerr << "Error index -- Index must be from 0 to 2" << i <<endl;
                return m_afVector[0];
        }
        return m_afVector[i];
}

inline const float &K3dVector3::operator[] ( int i ) const
{
        if ( ! ( 0 <= i ) && ( i < 3 ) )
        {
                cerr << "Error index -- Index must be from 0 to 2" << i <<endl;
                return m_afVector[0];
        }
        return m_afVector[i];
}

inline float K3dVector3::GetScalar ( const int i )
{
        if ( ! ( 0 <= i ) && ( i < 3 ) )
        {
                cerr << "Error index -- Index must be from 0 to 2" << i <<endl;
                return ( float ) 0;
        }
        return m_afVector[i];
}

inline void K3dVector3::SetScalar ( const float fScalar, const int i )
{
        if ( ! ( 0 <= i ) && ( i < 3 ) )
        {
                cerr << "Error index -- Index must be from 0 to 2" << i <<endl;
                return;
        }
        m_afVector[i] = fScalar;
}

inline void K3dVector3::Set ( float vector[3] )
{
        m_afVector[0] = vector[0];
        m_afVector[1] = vector[1];
        m_afVector[2] = vector[2];
}

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

inline void K3dVector3::SetX ( const float fX )
{
        m_afVector[0] = fX;
}

inline void K3dVector3::SetY ( const float fY )
{
        m_afVector[1] = fY;
}

inline void K3dVector3::SetZ ( const float fZ )
{
        m_afVector[2] = fZ;
}

inline void K3dVector3::Set ( K3dVector3 &_rV )
{
        m_afVector[0] = _rV.m_afVector[0];
        m_afVector[1] = _rV.m_afVector[1];
        m_afVector[2] = _rV.m_afVector[2];
}

---