OgreVector2.h

Go to the documentation of this file.
00001 /*
00002 -----------------------------------------------------------------------------
00003 This source file is part of OGRE
00004     (Object-oriented Graphics Rendering Engine)
00005 For the latest info, see http://www.ogre3d.org/
00006 
00007 Copyright (c) 2000-2006 Torus Knot Software Ltd
00008 Also see acknowledgements in Readme.html
00009 
00010 This program is free software; you can redistribute it and/or modify it under
00011 the terms of the GNU Lesser General Public License as published by the Free Software
00012 Foundation; either version 2 of the License, or (at your option) any later
00013 version.
00014 
00015 This program is distributed in the hope that it will be useful, but WITHOUT
00016 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
00017 FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
00018 
00019 You should have received a copy of the GNU Lesser General Public License along with
00020 this program; if not, write to the Free Software Foundation, Inc., 59 Temple
00021 Place - Suite 330, Boston, MA 02111-1307, USA, or go to
00022 http://www.gnu.org/copyleft/lesser.txt.
00023 
00024 You may alternatively use this source under the terms of a specific version of
00025 the OGRE Unrestricted License provided you have obtained such a license from
00026 Torus Knot Software Ltd.
00027 -----------------------------------------------------------------------------
00028 */
00029 #ifndef __Vector2_H__
00030 #define __Vector2_H__
00031 
00032 
00033 #include "OgrePrerequisites.h"
00034 #include "OgreMath.h"
00035 
00036 namespace Ogre
00037 {
00038 
00046     class _OgreExport Vector2
00047     {
00048     public:
00049         Real x, y;
00050 
00051     public:
00052         inline Vector2()
00053         {
00054         }
00055 
00056         inline Vector2(const Real fX, const Real fY )
00057             : x( fX ), y( fY )
00058         {
00059         }
00060 
00061         inline explicit Vector2( const Real scaler )
00062             : x( scaler), y( scaler )
00063         {
00064         }
00065 
00066         inline explicit Vector2( const Real afCoordinate[2] )
00067             : x( afCoordinate[0] ),
00068               y( afCoordinate[1] )
00069         {
00070         }
00071 
00072         inline explicit Vector2( const int afCoordinate[2] )
00073         {
00074             x = (Real)afCoordinate[0];
00075             y = (Real)afCoordinate[1];
00076         }
00077 
00078         inline explicit Vector2( Real* const r )
00079             : x( r[0] ), y( r[1] )
00080         {
00081         }
00082 
00083         inline Real operator [] ( const size_t i ) const
00084         {
00085             assert( i < 2 );
00086 
00087             return *(&x+i);
00088         }
00089 
00090         inline Real& operator [] ( const size_t i )
00091         {
00092             assert( i < 2 );
00093 
00094             return *(&x+i);
00095         }
00096 
00098         inline Real* ptr()
00099         {
00100             return &x;
00101         }
00103         inline const Real* ptr() const
00104         {
00105             return &x;
00106         }
00107 
00112         inline Vector2& operator = ( const Vector2& rkVector )
00113         {
00114             x = rkVector.x;
00115             y = rkVector.y;
00116 
00117             return *this;
00118         }
00119 
00120         inline Vector2& operator = ( const Real fScalar)
00121         {
00122             x = fScalar;
00123             y = fScalar;
00124 
00125             return *this;
00126         }
00127 
00128         inline bool operator == ( const Vector2& rkVector ) const
00129         {
00130             return ( x == rkVector.x && y == rkVector.y );
00131         }
00132 
00133         inline bool operator != ( const Vector2& rkVector ) const
00134         {
00135             return ( x != rkVector.x || y != rkVector.y  );
00136         }
00137 
00138         // arithmetic operations
00139         inline Vector2 operator + ( const Vector2& rkVector ) const
00140         {
00141             return Vector2(
00142                 x + rkVector.x,
00143                 y + rkVector.y);
00144         }
00145 
00146         inline Vector2 operator - ( const Vector2& rkVector ) const
00147         {
00148             return Vector2(
00149                 x - rkVector.x,
00150                 y - rkVector.y);
00151         }
00152 
00153         inline Vector2 operator * ( const Real fScalar ) const
00154         {
00155             return Vector2(
00156                 x * fScalar,
00157                 y * fScalar);
00158         }
00159 
00160         inline Vector2 operator * ( const Vector2& rhs) const
00161         {
00162             return Vector2(
00163                 x * rhs.x,
00164                 y * rhs.y);
00165         }
00166 
00167         inline Vector2 operator / ( const Real fScalar ) const
00168         {
00169             assert( fScalar != 0.0 );
00170 
00171             Real fInv = 1.0 / fScalar;
00172 
00173             return Vector2(
00174                 x * fInv,
00175                 y * fInv);
00176         }
00177 
00178         inline Vector2 operator / ( const Vector2& rhs) const
00179         {
00180             return Vector2(
00181                 x / rhs.x,
00182                 y / rhs.y);
00183         }
00184 
00185         inline const Vector2& operator + () const
00186         {
00187             return *this;
00188         }
00189 
00190         inline Vector2 operator - () const
00191         {
00192             return Vector2(-x, -y);
00193         }
00194 
00195         // overloaded operators to help Vector2
00196         inline friend Vector2 operator * ( const Real fScalar, const Vector2& rkVector )
00197         {
00198             return Vector2(
00199                 fScalar * rkVector.x,
00200                 fScalar * rkVector.y);
00201         }
00202 
00203         inline friend Vector2 operator / ( const Real fScalar, const Vector2& rkVector )
00204         {
00205             return Vector2(
00206                 fScalar / rkVector.x,
00207                 fScalar / rkVector.y);
00208         }
00209 
00210         inline friend Vector2 operator + (const Vector2& lhs, const Real rhs)
00211         {
00212             return Vector2(
00213                 lhs.x + rhs,
00214                 lhs.y + rhs);
00215         }
00216 
00217         inline friend Vector2 operator + (const Real lhs, const Vector2& rhs)
00218         {
00219             return Vector2(
00220                 lhs + rhs.x,
00221                 lhs + rhs.y);
00222         }
00223 
00224         inline friend Vector2 operator - (const Vector2& lhs, const Real rhs)
00225         {
00226             return Vector2(
00227                 lhs.x - rhs,
00228                 lhs.y - rhs);
00229         }
00230 
00231         inline friend Vector2 operator - (const Real lhs, const Vector2& rhs)
00232         {
00233             return Vector2(
00234                 lhs - rhs.x,
00235                 lhs - rhs.y);
00236         }
00237         // arithmetic updates
00238         inline Vector2& operator += ( const Vector2& rkVector )
00239         {
00240             x += rkVector.x;
00241             y += rkVector.y;
00242 
00243             return *this;
00244         }
00245 
00246         inline Vector2& operator += ( const Real fScaler )
00247         {
00248             x += fScaler;
00249             y += fScaler;
00250 
00251             return *this;
00252         }
00253 
00254         inline Vector2& operator -= ( const Vector2& rkVector )
00255         {
00256             x -= rkVector.x;
00257             y -= rkVector.y;
00258 
00259             return *this;
00260         }
00261 
00262         inline Vector2& operator -= ( const Real fScaler )
00263         {
00264             x -= fScaler;
00265             y -= fScaler;
00266 
00267             return *this;
00268         }
00269 
00270         inline Vector2& operator *= ( const Real fScalar )
00271         {
00272             x *= fScalar;
00273             y *= fScalar;
00274 
00275             return *this;
00276         }
00277 
00278         inline Vector2& operator *= ( const Vector2& rkVector )
00279         {
00280             x *= rkVector.x;
00281             y *= rkVector.y;
00282 
00283             return *this;
00284         }
00285 
00286         inline Vector2& operator /= ( const Real fScalar )
00287         {
00288             assert( fScalar != 0.0 );
00289 
00290             Real fInv = 1.0 / fScalar;
00291 
00292             x *= fInv;
00293             y *= fInv;
00294 
00295             return *this;
00296         }
00297 
00298         inline Vector2& operator /= ( const Vector2& rkVector )
00299         {
00300             x /= rkVector.x;
00301             y /= rkVector.y;
00302 
00303             return *this;
00304         }
00305 
00313         inline Real length () const
00314         {
00315             return Math::Sqrt( x * x + y * y );
00316         }
00317 
00328         inline Real squaredLength () const
00329         {
00330             return x * x + y * y;
00331         }
00332 
00347         inline Real dotProduct(const Vector2& vec) const
00348         {
00349             return x * vec.x + y * vec.y;
00350         }
00351 
00361         inline Real normalise()
00362         {
00363             Real fLength = Math::Sqrt( x * x + y * y);
00364 
00365             // Will also work for zero-sized vectors, but will change nothing
00366             if ( fLength > 1e-08 )
00367             {
00368                 Real fInvLength = 1.0 / fLength;
00369                 x *= fInvLength;
00370                 y *= fInvLength;
00371             }
00372 
00373             return fLength;
00374         }
00375 
00376 
00377 
00381         inline Vector2 midPoint( const Vector2& vec ) const
00382         {
00383             return Vector2(
00384                 ( x + vec.x ) * 0.5,
00385                 ( y + vec.y ) * 0.5 );
00386         }
00387 
00391         inline bool operator < ( const Vector2& rhs ) const
00392         {
00393             if( x < rhs.x && y < rhs.y )
00394                 return true;
00395             return false;
00396         }
00397 
00401         inline bool operator > ( const Vector2& rhs ) const
00402         {
00403             if( x > rhs.x && y > rhs.y )
00404                 return true;
00405             return false;
00406         }
00407 
00415         inline void makeFloor( const Vector2& cmp )
00416         {
00417             if( cmp.x < x ) x = cmp.x;
00418             if( cmp.y < y ) y = cmp.y;
00419         }
00420 
00428         inline void makeCeil( const Vector2& cmp )
00429         {
00430             if( cmp.x > x ) x = cmp.x;
00431             if( cmp.y > y ) y = cmp.y;
00432         }
00433 
00441         inline Vector2 perpendicular(void) const
00442         {
00443             return Vector2 (-y, x);
00444         }
00448         inline Real crossProduct( const Vector2& rkVector ) const
00449         {
00450             return x * rkVector.y - y * rkVector.x;
00451         }
00471         inline Vector2 randomDeviant(
00472             Real angle) const
00473         {
00474 
00475             angle *=  Math::UnitRandom() * Math::TWO_PI;
00476             Real cosa = cos(angle);
00477             Real sina = sin(angle);
00478             return  Vector2(cosa * x - sina * y,
00479                             sina * x + cosa * y);
00480         }
00481 
00483         inline bool isZeroLength(void) const
00484         {
00485             Real sqlen = (x * x) + (y * y);
00486             return (sqlen < (1e-06 * 1e-06));
00487 
00488         }
00489 
00492         inline Vector2 normalisedCopy(void) const
00493         {
00494             Vector2 ret = *this;
00495             ret.normalise();
00496             return ret;
00497         }
00498 
00502         inline Vector2 reflect(const Vector2& normal) const
00503         {
00504             return Vector2( *this - ( 2 * this->dotProduct(normal) * normal ) );
00505         }
00506 
00507         // special points
00508         static const Vector2 ZERO;
00509         static const Vector2 UNIT_X;
00510         static const Vector2 UNIT_Y;
00511         static const Vector2 NEGATIVE_UNIT_X;
00512         static const Vector2 NEGATIVE_UNIT_Y;
00513         static const Vector2 UNIT_SCALE;
00514 
00517         inline _OgreExport friend std::ostream& operator <<
00518             ( std::ostream& o, const Vector2& v )
00519         {
00520             o << "Vector2(" << v.x << ", " << v.y <<  ")";
00521             return o;
00522         }
00523 
00524     };
00525 
00526 }
00527 #endif

Copyright © 2008 Torus Knot Software Ltd
Creative Commons License
This work is licensed under a Creative Commons Attribution-ShareAlike 2.5 License.
Last modified Sun Sep 27 22:02:26 2009