ruby-procedural 0.0.1-x86-linux

data/deps/include/OgreProcedural/ProceduralMeshGenerator.h

@@ -0,0 +1,286 @@
+/*
+-----------------------------------------------------------------------------
+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

@@ -0,0 +1,126 @@
+/*
+-----------------------------------------------------------------------------
+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

@@ -0,0 +1,322 @@
+/*
+-----------------------------------------------------------------------------
+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