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



        // 2D vector class

        class K3dVector2
        {
                //      2d vector x,y
                float m_afVector[2];
                int m_iId;                              
        public:


                //      Reset constructor (0, 0) 
                K3dVector2();   
                //      Constructor set vector from array
                K3dVector2( const float vector[2] );
                //      Constructor set vector from x, y, z values
                K3dVector2( float x, float y);
                ~K3dVector2();

                // Coordinate access

                // Get vector array 
                float *GetVector();
                int &GetId()
                {
                        return m_iId;
                }
                // Overloaded operator[] allows set vector arrays  
                float &operator[]( int index) ;
                float operator[]( int index) const;
                // Get scalar by index
                float GetScalar(const int index);
                // Set value by index
                void SetScalar(const float fScalar, const int index);
                // Set vector from another vector
                void Set(  K3dVector2 vec );
                // Set vector from      array values
                void Set(  float vector[2] );
                // Set vector from      (x, y) values
                void Set( float x, float y);
                // Set X value
                void SetX(const float fX);
                // Set Y value
                void SetY(const float fY);
                float &GetX()
                {
                        return m_afVector[0];
                }
                float &GetY()
                {
                        return m_afVector[1];
                }

                // Assignment operator
                K3dVector2& operator= (const K3dVector2& rkV);

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


                // Arithmetic operations

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


                // Arithmetic updates

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



                // Functions
                // Calc square of vector
                K3dVector2 Sqr();
                // Add new vector to original vector
                void Add( const K3dVector2& vec );
                // Add value to scalar by index
                void AddScalar( const float fScalar, const int index );
                // Subtract value from scalar by index
                void SubtractScalar( const float fScalar, const int index );
                //      Reset vector to (0, 0) coordinates.
                void Reset();
                // Calculate vector length. 
                float Length();
                // Calc square vector length
                float SquaredLength ();
                //      Normalize vector
                void Normalize();
                // Calculate vector between two vectors (vec_1 - vec_2)
                void VectorBetween(K3dVector2 &_rkVec_1,K3dVector2 &_rkVec_2);
                // Add two vectors
                void AddVector(K3dVector2 &_rkVec_1, K3dVector2 &_rkVec_2);
                // Divide vector by divider d�itele
                void DivideVector(K3dVector2 &_rkVec, float divider);
                // Translate vector by direction vector
                void Translate(const K3dVector2 &_rkVertex, const K3dVector2 &_rkDirectVec, const float distance);
                // Invert vector
                void Invert();
                // Calculate dot product between two vectors
                float Dot( const K3dVector2 &_rkV);
                // Change vector to angle for rotation by vector
                void Angle();   

        };

        

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

        

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

        

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

        

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

        

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

        

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

        

        // Overloaded operator[] allows set vector arrays  
        inline float &K3dVector2::operator[]( int i )   
        { 
                if(!(0 <= i) && (i < 2) )
                {
                        cerr << "Error index -- Index must be from 0 to 1" << i <<endl;
                        return m_afVector[0];
                }
                return m_afVector[i]; 
        }

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

        

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

        

        // Get scalar by index
        inline float K3dVector2::GetScalar(const int i)
        {
                if(!(0 <= i) && (i < 2) ) 
                {
                        cerr << "Error index -- Index must be from 0 to 1" << i <<endl;
                        return (float)0;
                        //CDebug::InfoMsg("K3dVector2::GetScalar() -- error index", i);
                }
                return m_afVector[i];
        }

        

        // Set scalar by index
        inline void K3dVector2::SetScalar(const float fScalar, const int i)
        {
                if(!(0 <= i) && (i < 2) ) 
                {
                        cerr << "Error index -- Index must be from 0 to 1" << i <<endl;
                        return;
                        //CDebug::InfoMsg("K3dVector2::SetScalar() -- error index", i);
                }
                m_afVector[i] = fScalar;
        }

        

        // Translate vector by direction vector
        inline void K3dVector2::Translate(const K3dVector2 &_rkVertex, const K3dVector2 &_rkDirectVec, const float distance)
        {
                m_afVector[0] = _rkVertex.m_afVector[0] + (_rkDirectVec.m_afVector[0] * distance);
                m_afVector[1] = _rkVertex.m_afVector[1] + (_rkDirectVec.m_afVector[1] * distance);
        }

        

        // Invert vector
        inline void K3dVector2::Invert()
        {
                m_afVector[0] = -m_afVector[0];
                m_afVector[1] = -m_afVector[1];
        }

        


        // Calculate dot product between two vectors
        inline float K3dVector2::Dot(const K3dVector2 &_rkVector)
        {
                float fX,fY, fResult;
                fX = m_afVector[0] * _rkVector.m_afVector[0];
                fY = m_afVector[1] * _rkVector.m_afVector[1];
                fResult = fX + fY;
                return fResult;
        }

        

        //      Reset vector to (0, 0,) coordinates
        inline void K3dVector2::Reset()
        {
                m_afVector[0] = m_afVector[1] = 0;
        }

        

        // Set vector from another vector
        inline void K3dVector2::Set(  K3dVector2 vec )
        {
                m_afVector[0] = vec.m_afVector[0];
                m_afVector[1] = vec.m_afVector[1];
        }

        

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

        

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

        

        // Set X value
        inline void K3dVector2::SetX(const float fX)
        {
                m_afVector[0] = fX;
        }
        
        // Set Y value
        inline void K3dVector2::SetY(const float fY)
        {
                m_afVector[1] = fY;
        }
        

        //      Add new vector to original vector
        inline void K3dVector2::Add( const K3dVector2& vec )
        {
                m_afVector[0] += vec.m_afVector[0];
                m_afVector[1] += vec.m_afVector[1];
        }

        

        // Add value to scalar by index
        inline void K3dVector2::AddScalar( const float fScalar, const int i )
        {
                if(!(0 <= i) && (i < 2) ) 
                {
                        cerr << "Error index -- Index must be from 0 to 1" << i <<endl;
                        return;
                }
                m_afVector[i] += fScalar;
        }

        

        // Subtract value from scalar by index
        inline void K3dVector2::SubtractScalar( const float fScalar, const int i )
        {
                if(!(0 <= i) && (i < 2) ) 
                {
                        cerr << "Error index -- Index must be from 0 to 1" << i <<endl;
                        return;
                }
                m_afVector[i] -= fScalar;
        }

        


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

                float fLength0, fLength1;

                // Calculate vector lenght
                fLength0 = Length();    

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

        

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

        

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

                kV = *this;

                kV *= kV;

                return kV;
        }

        


        // Calculate vector between two vectors (vec_1 - vec_2)
        inline void K3dVector2::VectorBetween(K3dVector2 &_rkVec_1,K3dVector2 &_rkVec_2)
        {
                m_afVector[0] = _rkVec_1[0] - _rkVec_2[0];                      
                m_afVector[1] = _rkVec_1[1] - _rkVec_2[1];                                              
        }

        

        // Add two vectors
        inline void K3dVector2::AddVector(K3dVector2 &_rkVec_1, K3dVector2 &_rkVec_2)
        {
                m_afVector[0] = _rkVec_1[0] + _rkVec_2[0];                      
                m_afVector[1] = _rkVec_1[1] + _rkVec_2[1];                      
        }

        

        // Divide vector by divider 
        inline void K3dVector2::DivideVector(K3dVector2 &_rkVec, float divider)
        {
                if(divider!=0)
                {
                        m_afVector[0] = _rkVec[0] / divider;                    
                        m_afVector[1] = _rkVec[1] / divider;                            
                }
                else
                {
                        cerr << "inline void K3dVector2::DivideVector() -- Error - Divide by zero" << endl;
                }
        }

        

        // Change vector to angle for rotation by vector
        inline void K3dVector2::Angle()
        {
                // Slave vector
                K3dVector2 kV;
                // Length of vector
                float fLength;


                // Get length of actual vector
                fLength = this->Length();



                if(fLength)
                {
                        // Calculate length for multiplication instead dividing
                        fLength = 1/fLength;
                        // Calculate X angle
                        kV.m_afVector[0] = acos(this->m_afVector[0] * fLength);
                        // Calculate Y angle
                        kV.m_afVector[1] = acos(this->m_afVector[1] * fLength);// *  kV.m_afVector[0];
                        *this = kV;
                }
        }

---