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

data/deps/include/OgreProcedural/ProceduralMeshGenerator.h

@@ -1,286 +0,0 @@
-/*
------------------------------------------------------------------------------
-This source file is part of ogre-procedural
-
-For the latest info, see http://code.google.com/p/ogre-procedural/
-
-Copyright (c) 2010 Michael Broutin
-
-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 PROCEDURAL_MESH_GENERATOR_INCLUDED
-#define PROCEDURAL_MESH_GENERATOR_INCLUDED
-
-#include "OgreRectangle.h"
-#include "OgreSceneManager.h"
-#include "OgreMesh.h"
-#include "OgreManualObject.h"
-#include "ProceduralRoot.h"
-#include "ProceduralPlatform.h"
-#include "ProceduralTriangleBuffer.h"
-
-namespace Procedural
-{
-/** Superclass of everything that builds meshes
- */
-template <typename T>
-class MeshGenerator
-{
-protected:
-	/// A pointer to the default scene manager
-	Ogre::SceneManager* mSceneMgr;
-
-	/// U tile for texture coords generation
-	Ogre::Real mUTile;
-
-	/// V tile for texture coords generation
-	Ogre::Real mVTile;
-
-	/// Whether to produces normals or not
-	bool mEnableNormals;
-
-	/// The number of texture coordinate sets to include
-	unsigned char mNumTexCoordSet;
-
-	/// Rectangle in which the texture coordinates will be placed
-	Ogre::Vector2 mUVOrigin;
-
-	/// If set to true, the UV coordinates coming from the mesh generator will be switched.
-	/// It can be used, for example, if your texture doesn't fit the mesh generator's assumptions about UV.
-	/// If UV were to fit in a given rectangle, they still fit in it after the switch.
-	bool mSwitchUV;
-
-	/// Orientation to apply the mesh
-	Ogre::Quaternion mOrientation;
-
-	/// Scale to apply the mesh
-	Ogre::Vector3 mScale;
-
-	/// Position to apply to the mesh
-	Ogre::Vector3 mPosition;
-
-	// Whether a transform has been defined or not
-	bool mTransform;
-
-	// Debug output file
-	std::string mDumpFileName;
-
-	// Enable output to file or not
-	bool mEnableDumpToFile;
-
-public:
-	/// Default constructor
-	MeshGenerator() : mUTile(1.f),
-					  mVTile(1.f),
-					  mEnableNormals(true),
-					  mNumTexCoordSet(1),
-					  mUVOrigin(0,0),
-					  mSwitchUV(false),
-					  mOrientation(Ogre::Quaternion::IDENTITY),
-					  mScale(1,1,1),
-					  mPosition(0,0,0),
-					  mTransform(false),
-					  mDumpFileName(""),
-					  mEnableDumpToFile(false)
-	{
-		mSceneMgr = Ogre::Root::getSingleton().getSceneManagerIterator().begin()->second;
-		assert(mSceneMgr && "Scene Manager must be set in Root");
-	}
-
-	/**
-	 * Builds a mesh.
-	 * @param name of the mesh for the MeshManager
-	 * @param group ressource group in which the mesh will be created
-	 */
-	Ogre::MeshPtr realizeMesh(const std::string& name = "",
-		const Ogre::String& group = Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME)
-	{
-		TriangleBuffer tbuffer;
-		addToTriangleBuffer(tbuffer);
-		if (mEnableDumpToFile)
-			tbuffer._dumpContentsToFile(mDumpFileName);
-		Ogre::MeshPtr mesh;
-		if (name == "")
-			mesh = tbuffer.transformToMesh(Utils::getName(), group);
-		else
-			mesh = tbuffer.transformToMesh(name, group);
-		return mesh;
-	}
-
-	/**
-	 * Overloaded by each generator to implement the specifics
-	 */
-	virtual void addToTriangleBuffer(TriangleBuffer& buffer) const=0;
-
-	/**
-	 * Sets U Tile, ie the number by which u texture coordinates are multiplied (default=1)
-	 */
-	inline T& setUTile(Ogre::Real uTile)
-	{
-		mUTile = uTile;
-		return static_cast<T&>(*this);
-	}
-
-	/**
-	 * Sets V Tile, ie the number by which v texture coordinates are multiplied (default=1)
-	 */
-	inline T & setVTile(Ogre::Real vTile)
-	{
-		mVTile = vTile;
-		return static_cast<T&>(*this);
-	}
-
-	/**
-	 * Sets the texture rectangle
-	 */
-	inline T & setTextureRectangle(Ogre::Rectangle textureRectangle)
-	{
-		mUVOrigin = Ogre::Vector2(textureRectangle.top, textureRectangle.left);
-		mUTile = textureRectangle.right-textureRectangle.left;
-		mVTile = textureRectangle.bottom-textureRectangle.top;
-		return static_cast<T&>(*this);
-	}
-
-	/**
-	 * Sets whether normals are enabled or not (default=true)
-	 */
-	inline T & setEnableNormals(bool enableNormals)
-	{
-		mEnableNormals = enableNormals;
-		return static_cast<T&>(*this);
-	}
-
-	/**
-	 * Sets the number of texture coordintate sets (default=1)
-	 */
-	inline T & setNumTexCoordSet(unsigned char numTexCoordSet)
-	{
-		mNumTexCoordSet = numTexCoordSet;
-		return static_cast<T&>(*this);
-	}
-
-	/// Sets whether to switch U and V texture coordinates
-	inline T& setSwitchUV(bool switchUV)
-	{
-		mSwitchUV = switchUV;
-		return static_cast<T&>(*this);
-	}
-
-	/// Sets an orientation to give when building the mesh
-	inline T& setOrientation(const Ogre::Quaternion& orientation)
-	{
-		mOrientation = orientation;
-		mTransform = true;
-		return static_cast<T&>(*this);
-	}
-
-	/// Sets a translation baked into the resulting mesh
-	inline T& setPosition(const Ogre::Vector3& position)
-	{
-		mPosition = position;
-		mTransform = true;
-		return static_cast<T&>(*this);
-	}
-
-	/// Sets a translation baked into the resulting mesh
-	inline T& setPosition(Ogre::Real x, Ogre::Real y, Ogre::Real z)
-	{
-		mPosition = Ogre::Vector3(x, y, z);
-		mTransform = true;
-		return static_cast<T&>(*this);
-	}
-
-
-	/// Sets a scale baked into the resulting mesh
-	inline T& setScale(const Ogre::Vector3& scale)
-	{
-		mScale = scale;
-		mTransform = true;
-		return static_cast<T&>(*this);
-	}
-
-	/// Sets a uniform scale baked into the resulting mesh
-	inline T& setScale(Ogre::Real scale)
-	{
-		mScale = Ogre::Vector3(scale);
-		mTransform = true;
-		return static_cast<T&>(*this);
-	}
-
-	/// Sets a scale baked into the resulting mesh
-	inline T& setScale(Ogre::Real x, Ogre::Real y, Ogre::Real z)
-	{
-		mScale = Ogre::Vector3(x, y, z);
-		mTransform = true;
-		return static_cast<T&>(*this);
-	}
-
-	/// Resets all transforms (orientation, position and scale) that would have been applied to the mesh to their default values
-	inline T& resetTransforms()
-	{
-		mTransform = false;
-		mPosition = Ogre::Vector3::ZERO;
-		mOrientation = Ogre::Quaternion::IDENTITY;
-		mScale = Ogre::Vector3(1);
-		return static_cast<T&>(*this);
-	}
-
-	/// Activate dump to file
-	inline T& _setDumpToFile(const std::string& fileName)
-	{
-		mEnableDumpToFile = true;
-		mDumpFileName = fileName;
-		return static_cast<T&>(*this);
-	}
-
-	/// Disable dump to file
-	inline T& _disableDumpToFile()
-	{
-		mEnableDumpToFile = false;
-		return static_cast<T&>(*this);
-	}
-
-
-protected:
-	/// Adds a new point to a triangle buffer, using the format defined for that MeshGenerator
-	/// @arg buffer the triangle buffer to update
-	/// @arg position the position of the new point
-	/// @arg normal the normal of the new point
-	/// @arg uv the uv texcoord of the new point
-	inline void addPoint(TriangleBuffer& buffer, const Ogre::Vector3& position, const Ogre::Vector3& normal, const Ogre::Vector2& uv) const
-	{
-		if (mTransform)
-			buffer.position(mPosition + mOrientation * (mScale * position));
-		else
-			buffer.position(position);
-		if (mEnableNormals)
-			buffer.normal(normal);
-		if (mSwitchUV)
-			for (unsigned char i=0;i<mNumTexCoordSet;i++)
-				buffer.textureCoord(mUVOrigin.x + uv.y*mUTile, mUVOrigin.y+uv.x*mVTile);
-		else
-			for (unsigned char i=0;i<mNumTexCoordSet;i++)
-				buffer.textureCoord(mUVOrigin.x + uv.x*mUTile, mUVOrigin.y+uv.y*mVTile);
-	}
-
-};
-//
-}
-#endif

data/deps/include/OgreProcedural/ProceduralMultiShape.h

@@ -1,126 +0,0 @@
-/*
------------------------------------------------------------------------------
-This source file is part of ogre-procedural
-
-For the latest info, see http://code.google.com/p/ogre-procedural/
-
-Copyright (c) 2010 Michael Broutin
-
-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 PROCEDURAL_MULTISHAPE_INCLUDED
-#define PROCEDURAL_MULTISHAPE_INCLUDED
-
-#include "ProceduralRoot.h"
-
-namespace Procedural
-{
-	class Shape;
-
-/** Holds a bunch of shapes.
- * There are a number of assumptions that are made and are not checked
- * against : the shapes must not cross each other
- *
- */
-class _ProceduralExport MultiShape
-{
-	std::vector<Shape> mShapes;
-
-	public:
-	/// Default constructor
-	MultiShape()
-	{}
-
-	/// Constructor from a single shape
-	MultiShape(const Shape& shape)
-	{
-		mShapes.push_back(shape);
-	}
-
-	/// Constructor from a variable number of shapes
-	/// @arg count the number of shapes to add
-	/// @arg pointer to the shapes to add
-	MultiShape(int count, ...);
-
-	/// Adds a shape to the list of shapes
-	MultiShape& addShape(const Shape& shape)
-	{
-		mShapes.push_back(shape);
-		return *this;
-	}
-
-	/// Returns the i-th shape
-	const Shape& getShape(int i) const
-	{
-		return mShapes[i];
-	}
-
-	/// Returns the i-th shape
-	Shape& getShape(int i)
-	{
-		return mShapes[i];
-	}
-
-	/// Builds an aggregated list of all points contained in all shapes
-	std::vector<Ogre::Vector2> getPoints() const;
-
-	/// Returns the number of shapes in that MultiShape
-	int getShapeCount() const
-	{
-		return mShapes.size();
-	}
-
-	/// Append every shape of an other multishape to the current multiShape
-	void addMultiShape(const MultiShape& other)
-	{
-		for (std::vector<Shape>::const_iterator it = other.mShapes.begin(); it!=other.mShapes.end(); it++)
-		{
-			mShapes.push_back(*it);
-		}
-	}
-
-	/// Outputs the Multi Shape to a Mesh, mostly for visualisation or debugging purposes
-	Ogre::MeshPtr realizeMesh(const std::string& name="");
-
-	/// Tells whether a point is located inside that multishape
-	/// It assumes that all of the shapes in that multishape are closed,
-	/// and that they don't contradict each other,
-	/// ie a point cannot be outside and inside at the same time
-	bool isPointInside(const Ogre::Vector2& point) const;
-
-	/**
-	 * Tells whether multishape is "closed" or not.
-	 * MultiShape is considered to be closed if and only if all shapes are closed
-	 */
-	bool isClosed() const;
-
-	/**
-	 * Closes all shapes included in this multiShape
-	 */
-	void close();
-
-	/**
-	 * Determines whether the outside as defined by user equals "real" outside
-	 */
-	bool isOutsideRealOutside() const;
-
-};
-}
-#endif

data/deps/include/OgreProcedural/ProceduralPath.h

@@ -1,322 +0,0 @@
-/*
------------------------------------------------------------------------------
-This source file is part of ogre-procedural
-
-For the latest info, see http://code.google.com/p/ogre-procedural/
-
-Copyright (c) 2010 Michael Broutin
-
-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 PROCEDURAL_PATH_INCLUDED
-#define PROCEDURAL_PATH_INCLUDED
-
-#include "OgreVector3.h"
-#include "OgreSimpleSpline.h"
-#include "ProceduralUtils.h"
-#include "ProceduralPlatform.h"
-#include "ProceduralRoot.h"
-#include "ProceduralTrack.h"
-
-namespace Procedural
-{
-/** Succession of points in 3D space.
- * Can be closed or not.
- */
-class _ProceduralExport Path
-{
-	std::vector<Ogre::Vector3> mPoints;
-	bool mClosed;
-public:
-	/// Default constructor
-	Path() : mClosed(false)	{}
-
-	/** Adds a point to the path, as a Vector3 */
-	Path& addPoint(const Ogre::Vector3& pt)
-	{
-		mPoints.push_back(pt);
-		return *this;
-	}
-
-	/** Adds a point to the path, using its 3 coordinates */
-	Path& addPoint(Ogre::Real x, Ogre::Real y, Ogre::Real z)
-	{
-		mPoints.push_back(Ogre::Vector3(x,y,z));
-		return *this;
-	}
-
-	/// Inserts a point to the path
-	/// @arg index the index before the inserted point
-	/// @arg x new point's x coordinate
-	/// @arg y new point's y coordinate
-	/// @arg z new point's z coordinate
-	inline Path& insertPoint(size_t index, Ogre::Real x, Ogre::Real y, Ogre::Real z)
-	{
-		mPoints.insert(mPoints.begin()+index, Ogre::Vector3(x, y, z));
-		return *this;
-	}
-
-	/// Inserts a point to the path
-	/// @arg index the index before the inserted point
-	/// @arg pt new point's position
-	inline Path& insertPoint(size_t index, const Ogre::Vector3& pt)
-	{
-		mPoints.insert(mPoints.begin()+index, pt);
-		return *this;
-	}
-
-	/// Appends another path at the end of this one
-	inline Path& appendPath(const Path& other)
-	{
-		mPoints.insert(mPoints.end(), other.mPoints.begin(), other.mPoints.end());
-		return *this;
-	}
-	
-	/// Appends another path at the end of this one, relative to the last point of this path
-	inline Path& appendPathRel(const Path& other)
-	{
-		if (mPoints.empty())
-			appendPath(other);
-		else
-		{
-			Ogre::Vector3 refVector = *(mPoints.end()-1);
-			std::vector<Ogre::Vector3> pointList(other.mPoints.begin(), other.mPoints.end());
-			for (std::vector<Ogre::Vector3>::iterator it = pointList.begin(); it!=pointList.end(); it++)
-				*it += refVector;
-			mPoints.insert(mPoints.end(), pointList.begin(), pointList.end());
-		}
-		return *this;
-	}
-	
-	/** Clears the content of the Path */
-	Path& reset()
-	{
-		mPoints.clear();
-		return *this;
-	}
-
-	/** Define the path as being closed. Almost the same as adding a last point on the first point position */
-	Path& close()
-	{
-		assert(mPoints.size()>0 && "Cannot close an empty path");
-		mClosed = true;
-		return *this;
-	}
-	
-	/** Tells if the path is closed or not */
-	bool isClosed()
-	{
-		return mClosed;
-	}
-
-	/** Gets the list of points as a vector of Vector3 */
-	std::vector<Ogre::Vector3> getPoints()
-	{
-		return mPoints;
-	}
-
-	/// Gets raw vector data of this path as a non-const reference
-	inline std::vector<Ogre::Vector3>& getPointsReference()
-	{
-		return mPoints;
-	}
-
-	/** Safely gets a given point.
-	 * Takes into account whether the path is closed or not.
-	 * @param i the index of the point.
-	 *          if it is <0 or >maxPoint, cycle through the list of points
-	 */
-	const Ogre::Vector3& getPoint(int i) const
-	{
-		if (mClosed)
-			return mPoints[Utils::modulo(i,mPoints.size())];
-		return mPoints[Utils::cap(i,0,mPoints.size()-1)];
-	}
-
-	/** Gets the number of segments in the path
-	 * Takes into accound whether path is closed or not
-	 */
-	int getSegCount()
-	{
-		return (mPoints.size()-1) + (mClosed?1:0);
-	}
-
-	/**
-	 * Returns local direction after the current point
-	 */
-	Ogre::Vector3 getDirectionAfter(unsigned int i)
-	{
-		// If the path isn't closed, we get a different calculation at the end, because
-		// the tangent shall not be null
-		if (!mClosed && i == mPoints.size() - 1 && i > 0)
-			return (mPoints[i] - mPoints[i-1]).normalisedCopy();
-		else
-			return (getPoint(i+1) - getPoint(i)).normalisedCopy();
-	}
-
-	/**
-	 * Returns local direction after the current point
-	 */
-	Ogre::Vector3 getDirectionBefore(unsigned int i)
-	{
-		// If the path isn't closed, we get a different calculation at the end, because
-		// the tangent shall not be null
-		if (!mClosed && i == 1)
-			return (mPoints[1] - mPoints[0]).normalisedCopy();
-		else
-			return (getPoint(i) - getPoint(i-1)).normalisedCopy();
-	}
-
-	/**
-	 * Returns the local direction at the current point.
-	 * @param i index of the point
-	 */
-	Ogre::Vector3 getAvgDirection(unsigned int i)
-	{
-	    return (getDirectionAfter(i) + getDirectionBefore(i)).normalisedCopy();
-	}
-
-	/// Returns the total lineic length of that shape
-	Ogre::Real getTotalLength() const;
-
-	/// Gets a position on the shape with index of the point and a percentage of position on the segment
-	/// @arg i index of the segment
-	/// @arg coord a number between 0 and 1 meaning the percentage of position on the segment
-	inline Ogre::Vector3 getPosition(unsigned int i, Ogre::Real coord) const
-	{
-		assert(mClosed || (i < mPoints.size() - 1 && "Out of Bounds"));
-		assert(coord>=0. && coord<=1. && "Coord must be comprised between 0 and 1");
-		Ogre::Vector3 A = getPoint(i);
-		Ogre::Vector3 B = getPoint(i+1);
-		return A + coord*(B-A);
-	}
-	
-	/// Gets a position on the shape from lineic coordinate
-	/// @arg coord lineic coordinate
-	 Ogre::Vector3 getPosition(Ogre::Real coord) const;
-
-	/**
-	 * Outputs a mesh representing the path.
-	 * Mostly for debugging purposes
-	 */
-	Ogre::MeshPtr realizeMesh(const std::string& name = "");
-	
-	/// Creates a path with the keys of this path and extra keys coming from a track
-	Path mergeKeysWithTrack(const Track& track) const;
-
-		/**
-	 * Applies the given translation to all the points already defined.
-	 * Has strictly no effect on the points defined after that
-	 * @param translation the translation vector
-	 */
-	Path& translate(const Ogre::Vector3& translation)
-	{
-		for (std::vector<Ogre::Vector3>::iterator it = mPoints.begin(); it!=mPoints.end(); it++)
-			*it+=translation;
-		return *this;
-	}
-		
-	/**
-	 * Applies the given translation to all the points already defined.
-	 * Has strictly no effect on the points defined after that
-	 * @param translationX X component of the translation vector
-	 * @param translationY Y component of the translation vector
-	 * @param translationZ Z component of the translation vector
-	 */
-	Path& translate(Ogre::Real translationX, Ogre::Real translationY, Ogre::Real translationZ)
-	{
-		return translate(Ogre::Vector3(translationX, translationY, translationZ));
-	}
-
-	/**
-	 * Applies the given scale to all the points already defined.
-	 * Has strictly no effect on the points defined after that
-	 * @param amount amount of scale
-	 */	
-	Path& scale(Ogre::Real amount)
-	{
-		return scale(amount, amount, amount);
-	}
-
-	/**
-	 * Applies the given scale to all the points already defined.
-	 * Has strictly no effect on the points defined after that
-	 * @param scaleX amount of scale in the X direction
-	 * @param scaleY amount of scale in the Y direction
-	 * @param scaleZ amount of scale in the Z direction
-	 */	
-	Path& scale(Ogre::Real scaleX, Ogre::Real scaleY, Ogre::Real scaleZ)
-	{
-		for (std::vector<Ogre::Vector3>::iterator it = mPoints.begin(); it!=mPoints.end(); it++)
-		{
-			it->x *= scaleX;
-			it->y *= scaleY;			
-			it->z *= scaleZ;
-		}
-		return *this;
-	}
-
-	/**
-	 * Applies the given scale to all the points already defined.
-	 * Has strictly no effect on the points defined after that
-	 * @param amount of scale
-	 */	
-	Path& scale(const Ogre::Vector3& amount)
-	{
-		return scale(amount.x, amount.y, amount.z);
-	}
-
-	/**
-	 * Reflect all points in this path against a zero-origined plane with a given normal
-	 * @param the normal
-	 */
-	Path& reflect(const Ogre::Vector3& normal)
-	{
-		for (std::vector<Ogre::Vector3>::iterator it = mPoints.begin(); it!=mPoints.end(); it++)
-		{
-			*it = it->reflect(normal);
-		}
-		return *this;
-	}
-
-	/// Extracts a part of the shape as a new path
-	/// @arg first first index to be in the new path
-	/// @arg last last index to be in the new path
-	inline Path extractSubPath(unsigned int first, unsigned int last)
-	{
-		Path p;
-		for (unsigned int i=first;i<last;i++)
-			p.addPoint(mPoints[i]);
-		if (mClosed)
-			p.close();
-		return p;
-	}
-
-	/// Reverses direction of the path
-	inline Path& reverse()
-	{
-		std::reverse(mPoints.begin(), mPoints.end());
-		return *this;
-	}
-};
-
-}
-
-#endif