ruby-procedural 0.0.1-x86-linux

data/deps/include/OgreProcedural/ProceduralExtruder.h

@@ -0,0 +1,131 @@
+/*
+-----------------------------------------------------------------------------
+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_EXTRUDER_INCLUDED
+#define PROCEDURAL_EXTRUDER_INCLUDED
+
+#include "ProceduralShape.h"
+#include "ProceduralPath.h"
+#include "ProceduralPlatform.h"
+#include "ProceduralMeshGenerator.h"
+#include "ProceduralMultiShape.h"
+#include "ProceduralTrack.h"
+
+namespace Procedural
+{
+/// Extrudes a 2D shape along a path to build an extruded mesh.
+/// Can be used to build things such as pipelines, roads...
+///  
+/// Note : Concerning UV texCoords, U is along the path and V along the shape. 
+class _ProceduralExport Extruder : public MeshGenerator<Extruder>
+{
+	Shape* mShapeToExtrude;
+	MultiShape* mMultiShapeToExtrude;
+	Path* mExtrusionPath;
+	bool mCapped;
+	Track* mRotationTrack;
+	Track* mScaleTrack;
+	Track* mShapeTextureTrack;
+	Track* mPathTextureTrack;
+
+	void _extrudeBodyImpl(TriangleBuffer& buffer, const Shape* shapeToExtrude) const;
+
+	void _extrudeCapImpl(TriangleBuffer& buffer) const;
+	
+public:
+	/// Default constructor
+	Extruder() : mShapeToExtrude(0), mExtrusionPath(0), mCapped(true), mRotationTrack(0), mScaleTrack(0), mShapeTextureTrack(0), mPathTextureTrack(0)
+	{}
+	
+	/**
+	 * Builds the mesh into the given TriangleBuffer
+	 * @param buffer The TriangleBuffer on where to append the mesh.
+	 */
+	void addToTriangleBuffer(TriangleBuffer& buffer) const;
+
+	/** Sets the shape to extrude. Mutually exclusive with setMultiShapeToExtrude. */
+	inline Extruder & setShapeToExtrude(Shape* shapeToExtrude)
+	{
+		mMultiShapeToExtrude = 0;
+		mShapeToExtrude = shapeToExtrude;
+		return *this;
+	}
+
+	/** Sets the multishape to extrude. Mutually exclusive with setShapeToExtrude. */
+	inline Extruder & setMultiShapeToExtrude(MultiShape* multiShapeToExtrude)
+	{
+		mShapeToExtrude = 0;
+		mMultiShapeToExtrude = multiShapeToExtrude;
+		return *this;
+	}
+
+	/** Sets the extrusion path */
+	inline Extruder & setExtrusionPath(Path* extrusionPath)
+	{
+		mExtrusionPath = extrusionPath;
+		return *this;
+	}
+
+	/** Sets the rotation track (optional) */
+	inline Extruder& setRotationTrack(Track* rotationTrack)
+	{
+		mRotationTrack = rotationTrack;
+		return *this;
+	}
+
+	/** Sets the scale track (optional) */
+	inline Extruder& setScaleTrack(Track* scaleTrack)
+	{
+		mScaleTrack = scaleTrack;
+		return *this;
+	}
+	
+	/// Sets the track that maps shape points to V texture coords (optional).
+	/// Warning : if used with multishape, all shapes will have the same track.
+	inline Extruder& setShapeTextureTrack(Track* shapeTextureTrack) 
+	{
+		mShapeTextureTrack = shapeTextureTrack;
+		return *this;
+	}
+	
+	/// Sets the track that maps path points to V texture coord (optional).
+	inline Extruder& setPathTextureTrack(Track* pathTextureTrack)
+	{
+		mPathTextureTrack = pathTextureTrack;
+		return *this;
+	}
+
+	/** Sets whether caps are added to the extremities or not (not closed paths only) */
+	inline Extruder & setCapped(bool capped)
+	{
+		mCapped = capped;
+		return *this;
+	}
+};
+}
+
+#endif

data/deps/include/OgreProcedural/ProceduralGeometryHelpers.h

@@ -0,0 +1,171 @@
+/*
+-----------------------------------------------------------------------------
+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_GEOMETRYHELPERS_INCLUDED
+#define PROCEDURAL_GEOMETRYHELPERS_INCLUDED
+
+#include "OgrePlane.h"
+#include "OgreVector2.h"
+#include "OgreVector3.h"
+
+namespace Procedural
+{
+	class Line;
+//-----------------------------------------------------------------------
+/// Represents a 2D circle
+class Circle
+{
+	private:
+	Ogre::Vector2 mCenter;
+	Ogre::Real mRadius;
+	
+	public:
+
+	Circle() {}
+	
+	/// Contructor with arguments
+	Circle(Ogre::Vector2 center, Ogre::Real radius) : mCenter(center), mRadius(radius)
+	{}
+	
+	/// Contructor with arguments
+	Circle(Ogre::Vector2 p1, Ogre::Vector2 p2, Ogre::Vector2 p3);	
+	
+	/// Tells whether that point is inside the circle or not
+	bool isPointInside(const Ogre::Vector2& p) const
+	{
+		return (p-mCenter).length() < mRadius;
+	}
+};
+//-----------------------------------------------------------------------
+/// Extends the Ogre::Plane class to be able to compute the intersection between 2 planes
+class Plane : public Ogre::Plane
+{
+public:
+	Plane() : Ogre::Plane() {}
+	
+	/// Contructor with arguments
+	Plane(const Ogre::Vector3& normal, const Ogre::Vector3& pos) : Ogre::Plane(normal, pos) {}
+
+	/**
+	 * Checks whether 2 planes intersect and compute intersecting line if it is the case.
+	 * @arg other the other plane with which to check for intersection
+	 * @arg outputLine the intersecting line, if planes actually intersect
+	 * @returns true if planes intersect, false otherwise
+	 */
+	bool intersect(const Plane& other, Line& outputLine) const;
+};
+//-----------------------------------------------------------------------
+/// Represents a line in 3D
+class Line
+{
+	Ogre::Vector3 mPoint;
+	Ogre::Vector3 mDirection;
+
+public:
+	Line() {}
+	
+	/// Contructor with arguments
+	/// @arg point a point on the line
+	/// @arg direction a normalized vector representing the direction of that line
+	Line(Ogre::Vector3 point, Ogre::Vector3 direction) : mPoint(point), mDirection(direction.normalisedCopy()) {}
+
+	/// Builds the line between 2 points
+	void setFrom2Points(const Ogre::Vector3& a, const Ogre::Vector3& b)
+	{
+		mPoint = a;
+		mDirection = (b-a).normalisedCopy();
+	}
+
+	/// Finds the shortest vector between that line and a point
+	Ogre::Vector3 shortestPathToPoint(const Ogre::Vector3& point) const;
+};
+//-----------------------------------------------------------------------
+/// Represents a line in 2D
+class Line2D
+{
+	Ogre::Vector2 mPoint;
+	Ogre::Vector2 mDirection;
+
+public:
+	Line2D() {}
+	
+	/// Contructor with arguments
+	/// @arg point a point on the line
+	/// @arg direction a normalized vector representing the direction of that line
+	Line2D(Ogre::Vector2 point, Ogre::Vector2 direction) : mPoint(point), mDirection(direction.normalisedCopy()) {}
+
+	/// Builds the line between 2 points
+	void setFrom2Points(const Ogre::Vector2& a, const Ogre::Vector2& b)
+	{
+		mPoint = a;
+		mDirection = (b-a).normalisedCopy();
+	}
+
+	/**	  
+	 * Computes the interesction between current segment and another segment
+	 * @arg the other segment
+	 * @arg intersection the point of intersection if outputed there if it exists
+	 * @return true if segments intersect, false otherwise
+	 */
+	bool findIntersect(const Line2D& other, Ogre::Vector2& intersection) const;
+};
+//-----------------------------------------------------------------------
+/// Represents a 2D segment
+class Segment2D
+{
+	Ogre::Vector2 mA;
+	Ogre::Vector2 mB;
+	public:
+		
+	/// Contructor with arguments
+	Segment2D(Ogre::Vector2 a, Ogre::Vector2 b) : mA(a), mB(b) {}
+
+	/// Returns point A
+	Ogre::Vector2 getA()
+	{
+		return mA;	
+	}
+
+	/// Returns point B
+	Ogre::Vector2 getB()
+	{
+		return mB;
+	}
+
+	/**	  
+	 * Computes the interesction between current segment and another segment
+	 * @arg the other segment
+	 * @arg intersection the point of intersection if outputed there if it exists
+	 * @return true if segments intersect, false otherwise
+	 */
+	bool findIntersect(const Segment2D& other, Ogre::Vector2& intersection) const;
+
+	/// Tells whether this segments intersects the other segment
+	bool intersects(const Segment2D& other) const;
+};
+}
+#endif

data/deps/include/OgreProcedural/ProceduralIcoSphereGenerator.h

@@ -0,0 +1,76 @@
+/*
+-----------------------------------------------------------------------------
+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_ICOSPHERE_GENERATOR_INCLUDED
+#define PROCEDURAL_ICOSPHERE_GENERATOR_INCLUDED
+
+#include "ProceduralMeshGenerator.h"
+#include "ProceduralPlatform.h"
+
+namespace Procedural
+{
+/** Builds an icosphere mesh, ie a sphere built with equally sized triangles
+ */
+class _ProceduralExport IcoSphereGenerator : public MeshGenerator<IcoSphereGenerator>
+{
+	Ogre::Real mRadius;
+	unsigned int mNumIterations;
+
+public:	
+	/// Contructor with arguments
+	IcoSphereGenerator(Ogre::Real radius = 1.f, unsigned int numIterations = 2) : 
+		mRadius(radius),
+		mNumIterations(numIterations)
+	{}
+
+	/**
+	 * Builds the mesh into the given TriangleBuffer
+	 * @param buffer The TriangleBuffer on where to append the mesh.
+	 */
+	void addToTriangleBuffer(TriangleBuffer& buffer) const;
+
+	/** Sets the radius of the sphere (default=1) */
+	inline IcoSphereGenerator & setRadius(Ogre::Real radius)
+	{
+		mRadius = radius;
+		return *this;
+	}
+
+	/** Sets the number of iterations needed to build the sphere mesh.
+		First iteration corresponds to a 20 face sphere.
+		Each iteration has 3 more faces than the previous.
+		(default=2)
+	*/
+	inline IcoSphereGenerator & setNumIterations(unsigned int numIterations)
+	{
+		mNumIterations = numIterations;
+		return *this;
+	}
+
+};
+}
+#endif

data/deps/include/OgreProcedural/ProceduralLathe.h

@@ -0,0 +1,129 @@
+/*
+-----------------------------------------------------------------------------
+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_LATHE_INCLUDED
+#define PROCEDURAL_LATHE_INCLUDED
+
+#include "ProceduralShape.h"
+#include "ProceduralPlatform.h"
+#include "ProceduralMeshGenerator.h"
+
+namespace Procedural
+{
+/** Builds a mesh by rotating a shape 360� around Y-axis.
+ * The shape is assumed to be defined in the X>=0 half-plane
+ */
+class _ProceduralExport Lathe : public MeshGenerator<Lathe>
+{
+	Shape* mShapeToExtrude;	
+	MultiShape* mMultiShapeToExtrude;
+	int mNumSeg;
+	Ogre::Radian mAngleBegin;
+	Ogre::Radian mAngleEnd;	
+	bool mClosed;	
+	bool mCapped;
+	
+	void _latheCapImpl(TriangleBuffer& buffer) const;
+	void _latheBodyImpl(TriangleBuffer& buffer, const Shape* shapeToExtrude) const;
+
+public:	
+	/// Contructor with arguments
+	Lathe(Shape* shapeToExtrude = 0, int numSeg = 16) : mShapeToExtrude(shapeToExtrude), mMultiShapeToExtrude(0), 
+														mNumSeg(numSeg), mAngleBegin(0), mAngleEnd((Ogre::Radian)Ogre::Math::TWO_PI), mClosed(true), mCapped(true)
+	{}
+
+	/** Sets the number of segments when rotating around the axis (default=16)*/
+	inline Lathe& setNumSeg(int numSeg)
+	{
+		mNumSeg = numSeg;
+		return *this;
+	}
+	
+	/// Sets the angle to begin lathe with (default=0)
+	/// Automatically makes the lathe not closed
+	inline Lathe& setAngleBegin(Ogre::Radian angleBegin)
+	{
+		mAngleBegin = angleBegin;
+		mClosed = false;
+		return *this;
+	}
+	
+	/// Sets the angle to end lathe with (default=2PI)
+	/// Automatically makes the lathe not closed
+	inline Lathe& setAngleEnd(Ogre::Radian angleEnd)
+	{
+		mAngleEnd = angleEnd;
+		mClosed = false;
+		return *this;
+	}
+	
+	/// Sets whether the lathe is closed or not
+	inline Lathe& setClosed(bool closed)
+	{
+		mClosed = closed;
+		return *this;
+	}
+	
+	/// Sets whether the lathe is capped or not (default=true)
+	/// Only makes sense if the lathe is not closed.
+	inline Lathe& setCapped(bool capped)
+	{
+		mCapped = capped;
+		return *this;
+	}
+	
+	/** Sets the shape to extrude 	
+	  * If a multishape is already defined, auto-disables it
+	  * The shape is assumed to be defined in the X>=0 half-plane
+	  */
+	inline Lathe& setShapeToExtrude(Shape* shapeToExtrude)
+	{
+		mShapeToExtrude = shapeToExtrude;
+		mMultiShapeToExtrude = 0;
+		return *this;
+	}
+	
+	/** Sets the multiShape to extrude
+	  * If a shape is already defined, auto-disables it
+	  * The shapes in this multi-shape are assumed to be defined in the X>=0 half-plane
+	  */
+	inline Lathe& setMultiShapeToExtrude(MultiShape* multiShapeToExtrude)
+	{
+		mMultiShapeToExtrude = multiShapeToExtrude;
+		mShapeToExtrude = 0;
+		return *this;
+	}
+
+	/**
+	 * Builds the mesh into the given TriangleBuffer
+	 * @param buffer The TriangleBuffer on where to append the mesh.
+	 */
+	void addToTriangleBuffer(TriangleBuffer& buffer) const;
+};
+}
+
+#endif