ruby-ogre 0.0.5-x86-linux → 0.1.0-x86-linux

data/deps/include/OGRE/OgreUnifiedHighLevelGpuProgram.h

@@ -1,177 +0,0 @@
-/*
------------------------------------------------------------------------------
-This source file is part of OGRE
-(Object-oriented Graphics Rendering Engine)
-For the latest info, see http://www.ogre3d.org/
-
-Copyright (c) 2000-2012 Torus Knot Software Ltd
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
------------------------------------------------------------------------------
-*/
-#ifndef __UnifiedHighLevelGpuProgram_H__
-#define __UnifiedHighLevelGpuProgram_H__
-
-#include "OgrePrerequisites.h"
-#include "OgreHighLevelGpuProgram.h"
-#include "OgreHighLevelGpuProgramManager.h"
-
-namespace Ogre {
-
-	/** \addtogroup Core
-	*  @{
-	*/
-	/** \addtogroup Resources
-	*  @{
-	*/
-	/** Specialisation of HighLevelGpuProgram which just delegates its implementation
-		to one other high level program, allowing a single program definition
-		to represent one supported program from a number of options
-	@remarks
-		Whilst you can use Technique to implement several ways to render an object
-		depending on hardware support, if the only reason to need multiple paths is
-		because of the high-level shader language supported, this can be 
-		cumbersome. For example you might want to implement the same shader 
-		in HLSL and	GLSL for portability but apart from the implementation detail,
-		the shaders do the same thing and take the same parameters. If the materials
-		in question are complex, duplicating the techniques just to switch language
-		is not optimal, so instead you can define high-level programs with a 
-		syntax of 'unified', and list the actual implementations in order of
-		preference via repeated use of the 'delegate' parameter, which just points
-		at another program name. The first one which has a supported syntax 
-		will be used.
-	*/
-	class _OgreExport UnifiedHighLevelGpuProgram : public HighLevelGpuProgram
-	{
-	public:
-		/// Command object for setting delegate (can set more than once)
-		class CmdDelegate : public ParamCommand
-		{
-		public:
-			String doGet(const void* target) const;
-			void doSet(void* target, const String& val);
-		};
-
-	protected:
-		static CmdDelegate msCmdDelegate;
-
-		/// Ordered list of potential delegates
-		StringVector mDelegateNames;
-		/// The chosen delegate
-		mutable HighLevelGpuProgramPtr mChosenDelegate;
-
-		/// Choose the delegate to use
-		void chooseDelegate() const;
-
-		void createLowLevelImpl(void);
-		void unloadHighLevelImpl(void);
-		void buildConstantDefinitions() const;
-		void loadFromSource(void);
-
-	public:
-		/** Constructor, should be used only by factory classes. */
-		UnifiedHighLevelGpuProgram(ResourceManager* creator, const String& name, ResourceHandle handle,
-			const String& group, bool isManual = false, ManualResourceLoader* loader = 0);
-		~UnifiedHighLevelGpuProgram();
-
-
-		/** Adds a new delegate program to the list.
-		@remarks
-			Delegates are tested in order so earlier ones are preferred.
-		*/
-		void addDelegateProgram(const String& name);
-
-		/// Remove all delegate programs
-		void clearDelegatePrograms();
-
-		/// Get the chosen delegate
-		const HighLevelGpuProgramPtr& _getDelegate() const;
-
-		/** @copydoc GpuProgram::getLanguage */
-        const String& getLanguage(void) const;
-
-		/** Creates a new parameters object compatible with this program definition. 
-		@remarks
-		Unlike low-level assembly programs, parameters objects are specific to the
-		program and therefore must be created from it rather than by the 
-		HighLevelGpuProgramManager. This method creates a new instance of a parameters
-		object containing the definition of the parameters this program understands.
-		*/
-		GpuProgramParametersSharedPtr createParameters(void);
-		/** @copydoc GpuProgram::getBindingDelegate */
-		GpuProgram* _getBindingDelegate(void);
-
-		// All the following methods must delegate to the implementation
-
-		/** @copydoc GpuProgram::isSupported */
-		bool isSupported(void) const;
-		
-		/** @copydoc GpuProgram::isSkeletalAnimationIncluded */
-		bool isSkeletalAnimationIncluded(void) const;
-
-		bool isMorphAnimationIncluded(void) const;
-
-		bool isPoseAnimationIncluded(void) const;
-
-		bool isVertexTextureFetchRequired(void) const;
-		GpuProgramParametersSharedPtr getDefaultParameters(void);
-		bool hasDefaultParameters(void) const;
-		bool getPassSurfaceAndLightStates(void) const;
-		bool getPassFogStates(void) const;
-		bool getPassTransformStates(void) const;
-		bool hasCompileError(void) const;
-		void resetCompileError(void);
-
-		void load(bool backgroundThread = false);
-		void reload(void);
-		bool isReloadable(void) const;
-		bool isLoaded(void) const;
-		bool isLoading() const;
-		LoadingState getLoadingState() const;
-		void unload(void);
-		size_t getSize(void) const;
-		void touch(void);
-		bool isBackgroundLoaded(void) const;
-		void setBackgroundLoaded(bool bl);
-		void escalateLoading();
-		void addListener(Listener* lis);
-		void removeListener(Listener* lis);
-
-	};
-
-	/** Factory class for Unified programs. */
-	class UnifiedHighLevelGpuProgramFactory : public HighLevelGpuProgramFactory
-	{
-	public:
-		UnifiedHighLevelGpuProgramFactory();
-		~UnifiedHighLevelGpuProgramFactory();
-		/// Get the name of the language this factory creates programs for
-		const String& getLanguage(void) const;
-		HighLevelGpuProgram* create(ResourceManager* creator, 
-			const String& name, ResourceHandle handle,
-			const String& group, bool isManual, ManualResourceLoader* loader);
-		void destroy(HighLevelGpuProgram* prog);
-
-	};
-
-	/** @} */
-	/** @} */
-
-}
-#endif

data/deps/include/OGRE/OgreUserObjectBindings.h

@@ -1,140 +0,0 @@
-/*
------------------------------------------------------------------------------
-This source file is part of OGRE
-(Object-oriented Graphics Rendering Engine)
-For the latest info, see http://www.ogre3d.org/
-
-Copyright (c) 2000-2012 Torus Knot Software Ltd
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
------------------------------------------------------------------------------
-*/
-#ifndef _UserObjectsBinding_H__
-#define _UserObjectsBinding_H__
-
-#include "OgrePrerequisites.h"
-#include "OgreAny.h"
-
-namespace Ogre {
-
-	/** \addtogroup Core
-	*  @{
-	*/
-	/** \addtogroup Scene
-	*  @{
-	*/
-
-	/** Class that provide convenient interface to establish a linkage between
-	custom user application objects and Ogre core classes.
-	Any instance of Ogre class that will derive from this class could be associated with custom 
-	application object using this class interface.
-	*/
-	class _OgreExport UserObjectBindings : public GeneralAllocatedObject
-	{
-	public:	
-		/** Class constructor. */
-		UserObjectBindings();
-
-		/** Class destructor. */
-		virtual ~UserObjectBindings();
-
-		/** Sets any kind of user object on this class instance.
-		@remarks
-		This method allows you to associate any user object you like with 
-		this class. This can be a pointer back to one of your own
-		classes for instance.
-		@note This method is key less meaning that each call for it will override
-		previous object that were set. If you need to associate multiple objects
-		with this class use the extended version that takes key.
-		*/
-		void setUserAny(const Any& anything);
-
-		/** Retrieves the custom key less user object associated with this class.
-		*/
-		const Any& getUserAny(void) const;
-
-		/** Sets any kind of user object on this class instance.
-		@remarks
-		This method allows you to associate multiple object with this class. 
-		This can be a pointer back to one of your own classes for instance.
-		Use a unique key to distinguish between each of these objects. 
-		@param key The key that this data is associate with.
-		@param anything The data to associate with the given key.
-		*/
-		void setUserAny(const String& key, const Any& anything);
-
-		/** Retrieves the custom user object associated with this class and key.
-		@param key The key that the requested user object is associated with.
-		@remarks
-		In case no object associated with this key the returned Any object will be empty.
-		*/
-		const Any& getUserAny(const String& key) const;
-
-		/** Erase the custom user object associated with this class and key from this binding.
-		@param key The key that the requested user object is associated with.		
-		*/
-		void eraseUserAny(const String& key);
-
-		/** Clear all user objects from this binding.	*/
-		void clear() const;
-
-		/** Returns empty user any object.
-		*/
-		static const Any& getEmptyUserAny() { return msEmptyAny; }
-
-	// Types.
-	protected:		
-		typedef map<String, Any>::type			UserObjectsMap;
-		typedef UserObjectsMap::iterator		UserObjectsMapIterator;
-		typedef UserObjectsMap::const_iterator	UserObjectsMapConstIterator;
-
-		/** Internal class that uses as data storage container.
-		*/
-		class Attributes : public GeneralAllocatedObject
-		{
-		public:
-			/** Attribute storage ctor. */
-			Attributes() : mUserObjectsMap(NULL) {}
-
-			/** Attribute storage dtor. */
-			~Attributes()
-			{
-				if (mUserObjectsMap != NULL)
-				{
-					OGRE_DELETE mUserObjectsMap;
-					mUserObjectsMap = NULL;
-				}				
-			}
-
-			Any					mKeylessAny;		// Will hold key less associated user object for fast access. 	
-			UserObjectsMap*		mUserObjectsMap;	// Will hold a map between user keys to user objects.
-		};
-
-	// Attributes.
-	private:
-		static Any				msEmptyAny;			// Shared empty any object.
-		mutable Attributes*		mAttributes;		// Class attributes - will be allocated on demand.
-		
-	};
-
-	/** @} */
-	/** @} */
-}
-
-#endif

data/deps/include/OGRE/OgreVector2.h

@@ -1,609 +0,0 @@
-/*
------------------------------------------------------------------------------
-This source file is part of OGRE
-    (Object-oriented Graphics Rendering Engine)
-For the latest info, see http://www.ogre3d.org/
-
-Copyright (c) 2000-2012 Torus Knot Software Ltd
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
------------------------------------------------------------------------------
-*/
-#ifndef __Vector2_H__
-#define __Vector2_H__
-
-
-#include "OgrePrerequisites.h"
-#include "OgreMath.h"
-
-namespace Ogre
-{
-
-	/** \addtogroup Core
-	*  @{
-	*/
-	/** \addtogroup Math
-	*  @{
-	*/
-	/** Standard 2-dimensional vector.
-        @remarks
-            A direction in 2D space represented as distances along the 2
-            orthogonal axes (x, y). Note that positions, directions and
-            scaling factors can be represented by a vector, depending on how
-            you interpret the values.
-    */
-    class _OgreExport Vector2
-    {
-    public:
-        Real x, y;
-
-    public:
-        inline Vector2()
-        {
-        }
-
-        inline Vector2(const Real fX, const Real fY )
-            : x( fX ), y( fY )
-        {
-        }
-
-        inline explicit Vector2( const Real scaler )
-            : x( scaler), y( scaler )
-        {
-        }
-
-        inline explicit Vector2( const Real afCoordinate[2] )
-            : x( afCoordinate[0] ),
-              y( afCoordinate[1] )
-        {
-        }
-
-        inline explicit Vector2( const int afCoordinate[2] )
-        {
-            x = (Real)afCoordinate[0];
-            y = (Real)afCoordinate[1];
-        }
-
-        inline explicit Vector2( Real* const r )
-            : x( r[0] ), y( r[1] )
-        {
-        }
-
-		/** Exchange the contents of this vector with another. 
-		*/
-		inline void swap(Vector2& other)
-		{
-			std::swap(x, other.x);
-			std::swap(y, other.y);
-		}
-
-		inline Real operator [] ( const size_t i ) const
-        {
-            assert( i < 2 );
-
-            return *(&x+i);
-        }
-
-		inline Real& operator [] ( const size_t i )
-        {
-            assert( i < 2 );
-
-            return *(&x+i);
-        }
-
-		/// Pointer accessor for direct copying
-		inline Real* ptr()
-		{
-			return &x;
-		}
-		/// Pointer accessor for direct copying
-		inline const Real* ptr() const
-		{
-			return &x;
-		}
-
-        /** Assigns the value of the other vector.
-            @param
-                rkVector The other vector
-        */
-        inline Vector2& operator = ( const Vector2& rkVector )
-        {
-            x = rkVector.x;
-            y = rkVector.y;
-
-            return *this;
-        }
-
-		inline Vector2& operator = ( const Real fScalar)
-		{
-			x = fScalar;
-			y = fScalar;
-
-			return *this;
-		}
-
-        inline bool operator == ( const Vector2& rkVector ) const
-        {
-            return ( x == rkVector.x && y == rkVector.y );
-        }
-
-        inline bool operator != ( const Vector2& rkVector ) const
-        {
-            return ( x != rkVector.x || y != rkVector.y  );
-        }
-
-        // arithmetic operations
-        inline Vector2 operator + ( const Vector2& rkVector ) const
-        {
-            return Vector2(
-                x + rkVector.x,
-                y + rkVector.y);
-        }
-
-        inline Vector2 operator - ( const Vector2& rkVector ) const
-        {
-            return Vector2(
-                x - rkVector.x,
-                y - rkVector.y);
-        }
-
-        inline Vector2 operator * ( const Real fScalar ) const
-        {
-            return Vector2(
-                x * fScalar,
-                y * fScalar);
-        }
-
-        inline Vector2 operator * ( const Vector2& rhs) const
-        {
-            return Vector2(
-                x * rhs.x,
-                y * rhs.y);
-        }
-
-        inline Vector2 operator / ( const Real fScalar ) const
-        {
-            assert( fScalar != 0.0 );
-
-            Real fInv = 1.0f / fScalar;
-
-            return Vector2(
-                x * fInv,
-                y * fInv);
-        }
-
-        inline Vector2 operator / ( const Vector2& rhs) const
-        {
-            return Vector2(
-                x / rhs.x,
-                y / rhs.y);
-        }
-
-        inline const Vector2& operator + () const
-        {
-            return *this;
-        }
-
-        inline Vector2 operator - () const
-        {
-            return Vector2(-x, -y);
-        }
-
-        // overloaded operators to help Vector2
-        inline friend Vector2 operator * ( const Real fScalar, const Vector2& rkVector )
-        {
-            return Vector2(
-                fScalar * rkVector.x,
-                fScalar * rkVector.y);
-        }
-
-        inline friend Vector2 operator / ( const Real fScalar, const Vector2& rkVector )
-        {
-            return Vector2(
-                fScalar / rkVector.x,
-                fScalar / rkVector.y);
-        }
-
-        inline friend Vector2 operator + (const Vector2& lhs, const Real rhs)
-        {
-            return Vector2(
-                lhs.x + rhs,
-                lhs.y + rhs);
-        }
-
-        inline friend Vector2 operator + (const Real lhs, const Vector2& rhs)
-        {
-            return Vector2(
-                lhs + rhs.x,
-                lhs + rhs.y);
-        }
-
-        inline friend Vector2 operator - (const Vector2& lhs, const Real rhs)
-        {
-            return Vector2(
-                lhs.x - rhs,
-                lhs.y - rhs);
-        }
-
-        inline friend Vector2 operator - (const Real lhs, const Vector2& rhs)
-        {
-            return Vector2(
-                lhs - rhs.x,
-                lhs - rhs.y);
-        }
-
-        // arithmetic updates
-        inline Vector2& operator += ( const Vector2& rkVector )
-        {
-            x += rkVector.x;
-            y += rkVector.y;
-
-            return *this;
-        }
-
-        inline Vector2& operator += ( const Real fScaler )
-        {
-            x += fScaler;
-            y += fScaler;
-
-            return *this;
-        }
-
-        inline Vector2& operator -= ( const Vector2& rkVector )
-        {
-            x -= rkVector.x;
-            y -= rkVector.y;
-
-            return *this;
-        }
-
-        inline Vector2& operator -= ( const Real fScaler )
-        {
-            x -= fScaler;
-            y -= fScaler;
-
-            return *this;
-        }
-
-        inline Vector2& operator *= ( const Real fScalar )
-        {
-            x *= fScalar;
-            y *= fScalar;
-
-            return *this;
-        }
-
-        inline Vector2& operator *= ( const Vector2& rkVector )
-        {
-            x *= rkVector.x;
-            y *= rkVector.y;
-
-            return *this;
-        }
-
-        inline Vector2& operator /= ( const Real fScalar )
-        {
-            assert( fScalar != 0.0 );
-
-            Real fInv = 1.0f / fScalar;
-
-            x *= fInv;
-            y *= fInv;
-
-            return *this;
-        }
-
-        inline Vector2& operator /= ( const Vector2& rkVector )
-        {
-            x /= rkVector.x;
-            y /= rkVector.y;
-
-            return *this;
-        }
-
-        /** Returns the length (magnitude) of the vector.
-            @warning
-                This operation requires a square root and is expensive in
-                terms of CPU operations. If you don't need to know the exact
-                length (e.g. for just comparing lengths) use squaredLength()
-                instead.
-        */
-        inline Real length () const
-        {
-            return Math::Sqrt( x * x + y * y );
-        }
-
-        /** Returns the square of the length(magnitude) of the vector.
-            @remarks
-                This  method is for efficiency - calculating the actual
-                length of a vector requires a square root, which is expensive
-                in terms of the operations required. This method returns the
-                square of the length of the vector, i.e. the same as the
-                length but before the square root is taken. Use this if you
-                want to find the longest / shortest vector without incurring
-                the square root.
-        */
-        inline Real squaredLength () const
-        {
-            return x * x + y * y;
-        }
-
-        /** Returns the distance to another vector.
-            @warning
-                This operation requires a square root and is expensive in
-                terms of CPU operations. If you don't need to know the exact
-                distance (e.g. for just comparing distances) use squaredDistance()
-                instead.
-        */
-        inline Real distance(const Vector2& rhs) const
-        {
-            return (*this - rhs).length();
-        }
-
-        /** Returns the square of the distance to another vector.
-            @remarks
-                This method is for efficiency - calculating the actual
-                distance to another vector requires a square root, which is
-                expensive in terms of the operations required. This method
-                returns the square of the distance to another vector, i.e.
-                the same as the distance but before the square root is taken.
-                Use this if you want to find the longest / shortest distance
-                without incurring the square root.
-        */
-        inline Real squaredDistance(const Vector2& rhs) const
-        {
-            return (*this - rhs).squaredLength();
-        }
-
-        /** Calculates the dot (scalar) product of this vector with another.
-            @remarks
-                The dot product can be used to calculate the angle between 2
-                vectors. If both are unit vectors, the dot product is the
-                cosine of the angle; otherwise the dot product must be
-                divided by the product of the lengths of both vectors to get
-                the cosine of the angle. This result can further be used to
-                calculate the distance of a point from a plane.
-            @param
-                vec Vector with which to calculate the dot product (together
-                with this one).
-            @return
-                A float representing the dot product value.
-        */
-        inline Real dotProduct(const Vector2& vec) const
-        {
-            return x * vec.x + y * vec.y;
-        }
-
-        /** Normalises the vector.
-            @remarks
-                This method normalises the vector such that it's
-                length / magnitude is 1. The result is called a unit vector.
-            @note
-                This function will not crash for zero-sized vectors, but there
-                will be no changes made to their components.
-            @return The previous length of the vector.
-        */
-
-        inline Real normalise()
-        {
-            Real fLength = Math::Sqrt( x * x + y * y);
-
-            // Will also work for zero-sized vectors, but will change nothing
-			// We're not using epsilons because we don't need to.
-            // Read http://www.ogre3d.org/forums/viewtopic.php?f=4&t=61259
-            if ( fLength > Real(0.0f) )
-            {
-                Real fInvLength = 1.0f / fLength;
-                x *= fInvLength;
-                y *= fInvLength;
-            }
-
-            return fLength;
-        }
-
-        /** Returns a vector at a point half way between this and the passed
-            in vector.
-        */
-        inline Vector2 midPoint( const Vector2& vec ) const
-        {
-            return Vector2(
-                ( x + vec.x ) * 0.5f,
-                ( y + vec.y ) * 0.5f );
-        }
-
-        /** Returns true if the vector's scalar components are all greater
-            that the ones of the vector it is compared against.
-        */
-        inline bool operator < ( const Vector2& rhs ) const
-        {
-            if( x < rhs.x && y < rhs.y )
-                return true;
-            return false;
-        }
-
-        /** Returns true if the vector's scalar components are all smaller
-            that the ones of the vector it is compared against.
-        */
-        inline bool operator > ( const Vector2& rhs ) const
-        {
-            if( x > rhs.x && y > rhs.y )
-                return true;
-            return false;
-        }
-
-        /** Sets this vector's components to the minimum of its own and the
-            ones of the passed in vector.
-            @remarks
-                'Minimum' in this case means the combination of the lowest
-                value of x, y and z from both vectors. Lowest is taken just
-                numerically, not magnitude, so -1 < 0.
-        */
-        inline void makeFloor( const Vector2& cmp )
-        {
-            if( cmp.x < x ) x = cmp.x;
-            if( cmp.y < y ) y = cmp.y;
-        }
-
-        /** Sets this vector's components to the maximum of its own and the
-            ones of the passed in vector.
-            @remarks
-                'Maximum' in this case means the combination of the highest
-                value of x, y and z from both vectors. Highest is taken just
-                numerically, not magnitude, so 1 > -3.
-        */
-        inline void makeCeil( const Vector2& cmp )
-        {
-            if( cmp.x > x ) x = cmp.x;
-            if( cmp.y > y ) y = cmp.y;
-        }
-
-        /** Generates a vector perpendicular to this vector (eg an 'up' vector).
-            @remarks
-                This method will return a vector which is perpendicular to this
-                vector. There are an infinite number of possibilities but this
-                method will guarantee to generate one of them. If you need more
-                control you should use the Quaternion class.
-        */
-        inline Vector2 perpendicular(void) const
-        {
-            return Vector2 (-y, x);
-        }
-
-        /** Calculates the 2 dimensional cross-product of 2 vectors, which results
-			in a single floating point value which is 2 times the area of the triangle.
-        */
-        inline Real crossProduct( const Vector2& rkVector ) const
-        {
-            return x * rkVector.y - y * rkVector.x;
-        }
-
-        /** Generates a new random vector which deviates from this vector by a
-            given angle in a random direction.
-            @remarks
-                This method assumes that the random number generator has already
-                been seeded appropriately.
-            @param
-                angle The angle at which to deviate in radians
-            @param
-                up Any vector perpendicular to this one (which could generated
-                by cross-product of this vector and any other non-colinear
-                vector). If you choose not to provide this the function will
-                derive one on it's own, however if you provide one yourself the
-                function will be faster (this allows you to reuse up vectors if
-                you call this method more than once)
-            @return
-                A random vector which deviates from this vector by angle. This
-                vector will not be normalised, normalise it if you wish
-                afterwards.
-        */
-        inline Vector2 randomDeviant(Real angle) const
-        {
-
-            angle *=  Math::UnitRandom() * Math::TWO_PI;
-            Real cosa = cos(angle);
-            Real sina = sin(angle);
-            return  Vector2(cosa * x - sina * y,
-                            sina * x + cosa * y);
-        }
-
-        /** Returns true if this vector is zero length. */
-        inline bool isZeroLength(void) const
-        {
-            Real sqlen = (x * x) + (y * y);
-            return (sqlen < (1e-06 * 1e-06));
-
-        }
-
-        /** As normalise, except that this vector is unaffected and the
-            normalised vector is returned as a copy. */
-        inline Vector2 normalisedCopy(void) const
-        {
-            Vector2 ret = *this;
-            ret.normalise();
-            return ret;
-        }
-
-        /** Calculates a reflection vector to the plane with the given normal .
-        @remarks NB assumes 'this' is pointing AWAY FROM the plane, invert if it is not.
-        */
-        inline Vector2 reflect(const Vector2& normal) const
-        {
-            return Vector2( *this - ( 2 * this->dotProduct(normal) * normal ) );
-        }
-
-		/// Check whether this vector contains valid values
-		inline bool isNaN() const
-		{
-			return Math::isNaN(x) || Math::isNaN(y);
-		}
-
-		/**	 Gets the angle between 2 vectors.
-		@remarks
-			Vectors do not have to be unit-length but must represent directions.
-		*/
-		inline Ogre::Radian angleBetween(const Ogre::Vector2& other) const
-		{		
-			Ogre::Real lenProduct = length() * other.length();
-			// Divide by zero check
-			if(lenProduct < 1e-6f)
-				lenProduct = 1e-6f;
-		
-			Ogre::Real f = dotProduct(other) / lenProduct;
-	
-			f = Ogre::Math::Clamp(f, (Ogre::Real)-1.0, (Ogre::Real)1.0);
-			return Ogre::Math::ACos(f);
-		}
-
-		/**	 Gets the oriented angle between 2 vectors.
-		@remarks
-			Vectors do not have to be unit-length but must represent directions.
-			The angle is comprised between 0 and 2 PI.
-		*/
-		inline Ogre::Radian angleTo(const Ogre::Vector2& other) const
-		{
-			Ogre::Radian angle = angleBetween(other);
-		
-			if (crossProduct(other)<0)			
-				angle = (Ogre::Radian)Ogre::Math::TWO_PI - angle;		
-
-			return angle;
-		}
-
-        // special points
-        static const Vector2 ZERO;
-        static const Vector2 UNIT_X;
-        static const Vector2 UNIT_Y;
-        static const Vector2 NEGATIVE_UNIT_X;
-        static const Vector2 NEGATIVE_UNIT_Y;
-        static const Vector2 UNIT_SCALE;
-
-        /** Function for writing to a stream.
-        */
-        inline _OgreExport friend std::ostream& operator <<
-            ( std::ostream& o, const Vector2& v )
-        {
-            o << "Vector2(" << v.x << ", " << v.y <<  ")";
-            return o;
-        }
-    };
-	/** @} */
-	/** @} */
-
-}
-#endif