Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages

# 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 Vector2( const Vector2& rkVector )
    00084             : x( rkVector.x ), y( rkVector.y )
    00085         {
    00086         }
    00087
    00088         inline Real operator [] ( const size_t i ) const
    00089         {
    00090             assert( i < 2 );
    00091
    00092             return *(&x+i);
    00093         }
    00094
    00095         inline Real& operator [] ( const size_t i )
    00096         {
    00097             assert( i < 2 );
    00098
    00099             return *(&x+i);
    00100         }
    00101
    00103         inline Real* ptr()
    00104         {
    00105             return &x;
    00106         }
    00108         inline const Real* ptr() const
    00109         {
    00110             return &x;
    00111         }
    00112
    00117         inline Vector2& operator = ( const Vector2& rkVector )
    00118         {
    00119             x = rkVector.x;
    00120             y = rkVector.y;
    00121
    00122             return *this;
    00123         }
    00124
    00125         inline Vector2& operator = ( const Real fScalar)
    00126         {
    00127             x = fScalar;
    00128             y = fScalar;
    00129
    00130             return *this;
    00131         }
    00132
    00133         inline bool operator == ( const Vector2& rkVector ) const
    00134         {
    00135             return ( x == rkVector.x && y == rkVector.y );
    00136         }
    00137
    00138         inline bool operator != ( const Vector2& rkVector ) const
    00139         {
    00140             return ( x != rkVector.x || y != rkVector.y  );
    00141         }
    00142
    00143         // arithmetic operations
    00144         inline Vector2 operator + ( const Vector2& rkVector ) const
    00145         {
    00146             return Vector2(
    00147                 x + rkVector.x,
    00148                 y + rkVector.y);
    00149         }
    00150
    00151         inline Vector2 operator - ( const Vector2& rkVector ) const
    00152         {
    00153             return Vector2(
    00154                 x - rkVector.x,
    00155                 y - rkVector.y);
    00156         }
    00157
    00158         inline Vector2 operator * ( const Real fScalar ) const
    00159         {
    00160             return Vector2(
    00161                 x * fScalar,
    00162                 y * fScalar);
    00163         }
    00164
    00165         inline Vector2 operator * ( const Vector2& rhs) const
    00166         {
    00167             return Vector2(
    00168                 x * rhs.x,
    00169                 y * rhs.y);
    00170         }
    00171
    00172         inline Vector2 operator / ( const Real fScalar ) const
    00173         {
    00174             assert( fScalar != 0.0 );
    00175
    00176             Real fInv = 1.0 / fScalar;
    00177
    00178             return Vector2(
    00179                 x * fInv,
    00180                 y * fInv);
    00181         }
    00182
    00183         inline Vector2 operator / ( const Vector2& rhs) const
    00184         {
    00185             return Vector2(
    00186                 x / rhs.x,
    00187                 y / rhs.y);
    00188         }
    00189
    00190         inline const Vector2& operator + () const
    00191         {
    00192             return *this;
    00193         }
    00194
    00195         inline Vector2 operator - () const
    00196         {
    00197             return Vector2(-x, -y);
    00198         }
    00199
    00200         // overloaded operators to help Vector2
    00201         inline friend Vector2 operator * ( const Real fScalar, const Vector2& rkVector )
    00202         {
    00203             return Vector2(
    00204                 fScalar * rkVector.x,
    00205                 fScalar * rkVector.y);
    00206         }
    00207
    00208         inline friend Vector2 operator / ( const Real fScalar, const Vector2& rkVector )
    00209         {
    00210             return Vector2(
    00211                 fScalar / rkVector.x,
    00212                 fScalar / rkVector.y);
    00213         }
    00214
    00215         inline friend Vector2 operator + (const Vector2& lhs, const Real rhs)
    00216         {
    00217             return Vector2(
    00218                 lhs.x + rhs,
    00219                 lhs.y + rhs);
    00220         }
    00221
    00222         inline friend Vector2 operator + (const Real lhs, const Vector2& rhs)
    00223         {
    00224             return Vector2(
    00225                 lhs + rhs.x,
    00226                 lhs + rhs.y);
    00227         }
    00228
    00229         inline friend Vector2 operator - (const Vector2& lhs, const Real rhs)
    00230         {
    00231             return Vector2(
    00232                 lhs.x - rhs,
    00233                 lhs.y - rhs);
    00234         }
    00235
    00236         inline friend Vector2 operator - (const Real lhs, const Vector2& rhs)
    00237         {
    00238             return Vector2(
    00239                 lhs - rhs.x,
    00240                 lhs - rhs.y);
    00241         }
    00242         // arithmetic updates
    00243         inline Vector2& operator += ( const Vector2& rkVector )
    00244         {
    00245             x += rkVector.x;
    00246             y += rkVector.y;
    00247
    00248             return *this;
    00249         }
    00250
    00251         inline Vector2& operator += ( const Real fScaler )
    00252         {
    00253             x += fScaler;
    00254             y += fScaler;
    00255
    00256             return *this;
    00257         }
    00258
    00259         inline Vector2& operator -= ( const Vector2& rkVector )
    00260         {
    00261             x -= rkVector.x;
    00262             y -= rkVector.y;
    00263
    00264             return *this;
    00265         }
    00266
    00267         inline Vector2& operator -= ( const Real fScaler )
    00268         {
    00269             x -= fScaler;
    00270             y -= fScaler;
    00271
    00272             return *this;
    00273         }
    00274
    00275         inline Vector2& operator *= ( const Real fScalar )
    00276         {
    00277             x *= fScalar;
    00278             y *= fScalar;
    00279
    00280             return *this;
    00281         }
    00282
    00283         inline Vector2& operator *= ( const Vector2& rkVector )
    00284         {
    00285             x *= rkVector.x;
    00286             y *= rkVector.y;
    00287
    00288             return *this;
    00289         }
    00290
    00291         inline Vector2& operator /= ( const Real fScalar )
    00292         {
    00293             assert( fScalar != 0.0 );
    00294
    00295             Real fInv = 1.0 / fScalar;
    00296
    00297             x *= fInv;
    00298             y *= fInv;
    00299
    00300             return *this;
    00301         }
    00302
    00303         inline Vector2& operator /= ( const Vector2& rkVector )
    00304         {
    00305             x /= rkVector.x;
    00306             y /= rkVector.y;
    00307
    00308             return *this;
    00309         }
    00310
    00318         inline Real length () const
    00319         {
    00320             return Math::Sqrt( x * x + y * y );
    00321         }
    00322
    00333         inline Real squaredLength () const
    00334         {
    00335             return x * x + y * y;
    00336         }
    00337
    00352         inline Real dotProduct(const Vector2& vec) const
    00353         {
    00354             return x * vec.x + y * vec.y;
    00355         }
    00356
    00366         inline Real normalise()
    00367         {
    00368             Real fLength = Math::Sqrt( x * x + y * y);
    00369
    00370             // Will also work for zero-sized vectors, but will change nothing
    00371             if ( fLength > 1e-08 )
    00372             {
    00373                 Real fInvLength = 1.0 / fLength;
    00374                 x *= fInvLength;
    00375                 y *= fInvLength;
    00376             }
    00377
    00378             return fLength;
    00379         }
    00380
    00381
    00382
    00386         inline Vector2 midPoint( const Vector2& vec ) const
    00387         {
    00388             return Vector2(
    00389                 ( x + vec.x ) * 0.5,
    00390                 ( y + vec.y ) * 0.5 );
    00391         }
    00392
    00396         inline bool operator < ( const Vector2& rhs ) const
    00397         {
    00398             if( x < rhs.x && y < rhs.y )
    00399                 return true;
    00400             return false;
    00401         }
    00402
    00406         inline bool operator > ( const Vector2& rhs ) const
    00407         {
    00408             if( x > rhs.x && y > rhs.y )
    00409                 return true;
    00410             return false;
    00411         }
    00412
    00420         inline void makeFloor( const Vector2& cmp )
    00421         {
    00422             if( cmp.x < x ) x = cmp.x;
    00423             if( cmp.y < y ) y = cmp.y;
    00424         }
    00425
    00433         inline void makeCeil( const Vector2& cmp )
    00434         {
    00435             if( cmp.x > x ) x = cmp.x;
    00436             if( cmp.y > y ) y = cmp.y;
    00437         }
    00438
    00446         inline Vector2 perpendicular(void) const
    00447         {
    00448             return Vector2 (-y, x);
    00449         }
    00453         inline Real crossProduct( const Vector2& rkVector ) const
    00454         {
    00455             return x * rkVector.y - y * rkVector.x;
    00456         }
    00476         inline Vector2 randomDeviant(
    00477             Real angle) const
    00478         {
    00479
    00480             angle *=  Math::UnitRandom() * Math::TWO_PI;
    00481             Real cosa = cos(angle);
    00482             Real sina = sin(angle);
    00483             return  Vector2(cosa * x - sina * y,
    00484                             sina * x + cosa * y);
    00485         }
    00486
    00488         inline bool isZeroLength(void) const
    00489         {
    00490             Real sqlen = (x * x) + (y * y);
    00491             return (sqlen < (1e-06 * 1e-06));
    00492
    00493         }
    00494
    00497         inline Vector2 normalisedCopy(void) const
    00498         {
    00499             Vector2 ret = *this;
    00500             ret.normalise();
    00501             return ret;
    00502         }
    00503
    00507         inline Vector2 reflect(const Vector2& normal) const
    00508         {
    00509             return Vector2( *this - ( 2 * this->dotProduct(normal) * normal ) );
    00510         }
    00511
    00512         // special points
    00513         static const Vector2 ZERO;
    00514         static const Vector2 UNIT_X;
    00515         static const Vector2 UNIT_Y;
    00516         static const Vector2 NEGATIVE_UNIT_X;
    00517         static const Vector2 NEGATIVE_UNIT_Y;
    00518         static const Vector2 UNIT_SCALE;
    00519
    00522         inline _OgreExport friend std::ostream& operator <<
    00523             ( std::ostream& o, const Vector2& v )
    00524         {
    00525             o << "Vector2(" << v.x << ", " << v.y <<  ")";
    00526             return o;
    00527         }
    00528
    00529     };
    00530
    00531 }
    00532 #endif

Copyright © 2000-2005 by The OGRE Team
This work is licensed under a Creative Commons Attribution-ShareAlike 2.5 License.
Last modified Sun Sep 30 10:50:57 2007