ruby-procedural 0.0.1-x86-linux

data/deps/include/OgreProcedural/ProceduralShapeGenerators.h

@@ -0,0 +1,362 @@
+/*
+-----------------------------------------------------------------------------
+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_SHAPE_GENERATORS_INCLUDED
+#define PROCEDURAL_SHAPE_GENERATORS_INCLUDED
+
+#include "ProceduralShape.h"
+#include "ProceduralSplines.h"
+
+namespace Procedural
+{
+//-----------------------------------------------------------------------
+/// Base class for Shape generators
+template<class T>
+class BaseSpline2
+{
+protected:
+	/// The number of segments between 2 control points
+	unsigned int mNumSeg;
+	/// Whether the shape will be closed or not
+	bool mClosed;
+	/// The "out" side of the shape
+	Side mOutSide;
+public:
+	/// Default constructor
+	BaseSpline2() : mNumSeg(4), mClosed(false), mOutSide(SIDE_RIGHT) {}
+	
+	/// Sets the out side of the shape
+	inline T& setOutSide(Side outSide)
+	{
+		mOutSide = outSide;
+		return (T&)*this;
+	}
+
+	/// Gets the out side of the shape
+	inline Side getOutSide() const
+	{
+		return mOutSide;
+	}
+
+	/// Sets the number of segments between 2 control points
+	inline T& setNumSeg(unsigned int numSeg)
+	{
+		assert(numSeg>=1);
+		mNumSeg = numSeg;
+		return (T&)*this;
+	}
+
+	/// Closes the spline
+	inline T& close()
+	{
+		mClosed = true;
+		return (T&)*this;
+	}
+};
+
+//-----------------------------------------------------------------------
+/**
+ * Produces a shape from Cubic Hermite control points
+ */
+class _ProceduralExport CubicHermiteSpline2 : public BaseSpline2<CubicHermiteSpline2>
+{	
+	typedef CubicHermiteSplineControlPoint<Ogre::Vector2> ControlPoint;
+
+	std::vector<ControlPoint> mPoints;	
+	
+public:
+	/// Adds a control point
+	inline CubicHermiteSpline2& addPoint(const Ogre::Vector2& p, const Ogre::Vector2& before, const Ogre::Vector2& after)
+	{
+		mPoints.push_back(ControlPoint(p, before, after));
+		return *this;
+	}
+	/// Adds a control point
+	inline CubicHermiteSpline2& addPoint(const Ogre::Vector2& p, const Ogre::Vector2& tangent)
+	{
+		mPoints.push_back(ControlPoint(p, tangent, tangent));
+		return *this;
+	}
+	/// Adds a control point
+	inline CubicHermiteSpline2& addPoint(const Ogre::Vector2& p, CubicHermiteSplineAutoTangentMode autoTangentMode = AT_CATMULL)
+	{
+		ControlPoint cp;
+		cp.position = p;
+		cp.autoTangentBefore = autoTangentMode;
+		cp.autoTangentAfter = autoTangentMode;
+		mPoints.push_back(cp);
+		return *this;
+	}
+
+		/// Adds a control point
+	inline CubicHermiteSpline2& addPoint(Ogre::Real x, Ogre::Real y, CubicHermiteSplineAutoTangentMode autoTangentMode = AT_CATMULL)
+	{
+		ControlPoint cp;
+		cp.position = Ogre::Vector2(x,y);
+		cp.autoTangentBefore = autoTangentMode;
+		cp.autoTangentAfter = autoTangentMode;
+		mPoints.push_back(cp);
+		return *this;
+	}
+
+	/// Safely gets a control point
+	inline const ControlPoint& safeGetPoint(unsigned int i) const
+	{
+		if (mClosed)
+			return mPoints[Utils::modulo(i,mPoints.size())];
+		return mPoints[Utils::cap(i,0,mPoints.size()-1)];
+	}
+
+	/**
+	 * Builds a shape from control points
+	 */
+	Shape realizeShape();
+};
+
+//-----------------------------------------------------------------------
+/**
+ * Builds a shape from a Catmull-Rom Spline.
+ * A catmull-rom smoothly interpolates position between control points
+ */
+class _ProceduralExport CatmullRomSpline2 : public BaseSpline2<CatmullRomSpline2>
+{	
+	std::vector<Ogre::Vector2> mPoints;
+	public:	
+	/// Adds a control point
+	inline CatmullRomSpline2& addPoint(const Ogre::Vector2& pt)
+	{
+		mPoints.push_back(pt);
+		return *this;
+	}
+
+	/// Adds a control point
+	inline CatmullRomSpline2& addPoint(Ogre::Real x, Ogre::Real y)
+	{
+		mPoints.push_back(Ogre::Vector2(x,y));
+		return *this;
+	}
+	
+	/// Safely gets a control point
+	inline const Ogre::Vector2& safeGetPoint(unsigned int i) const
+	{
+		if (mClosed)
+			return mPoints[Utils::modulo(i,mPoints.size())];
+		return mPoints[Utils::cap(i,0,mPoints.size()-1)];
+	}
+	
+	/**
+	 * Build a shape from bezier control points
+	 */
+	Shape realizeShape();
+};
+
+//-----------------------------------------------------------------------
+/**
+ * Builds a shape from a Kochanek Bartels spline.
+ *
+ * More details here : http://en.wikipedia.org/wiki/Kochanek%E2%80%93Bartels_spline
+ */
+class _ProceduralExport KochanekBartelsSpline2 : public BaseSpline2<KochanekBartelsSpline2>
+{	
+	typedef KochanekBartelsSplineControlPoint<Ogre::Vector2> ControlPoint;
+	
+	std::vector<ControlPoint> mPoints;
+	
+public:
+	/// Adds a control point
+	inline KochanekBartelsSpline2& addPoint(Ogre::Real x, Ogre::Real y)
+	{
+		mPoints.push_back(ControlPoint(Ogre::Vector2(x,y)));
+		return *this;
+	}
+
+	/// Adds a control point
+	inline KochanekBartelsSpline2& addPoint(Ogre::Vector2 p)
+	{
+		mPoints.push_back(ControlPoint(p));
+		return *this;
+	}
+
+	/// Safely gets a control point
+	inline const ControlPoint& safeGetPoint(unsigned int i) const
+	{
+		if (mClosed)
+			return mPoints[Utils::modulo(i,mPoints.size())];
+		return mPoints[Utils::cap(i,0,mPoints.size()-1)];
+	}
+
+	/**
+	 * Adds a control point to the spline
+	 * @arg p Point position
+	 * @arg t Tension    +1 = Tight            -1 = Round
+	 * @arg b Bias       +1 = Post-shoot       -1 = Pre-shoot
+	 * @arg c Continuity +1 = Inverted Corners -1 = Box Corners
+	 */
+	inline KochanekBartelsSpline2& addPoint(Ogre::Vector2 p, Ogre::Real t, Ogre::Real b, Ogre::Real c)
+	{
+		mPoints.push_back(ControlPoint(p,t,b,c));
+		return *this;
+	}
+
+	/**
+	 * Builds a shape from control points
+	 */
+	Shape realizeShape();
+	
+};
+
+//-----------------------------------------------------------------------
+/**
+ * Builds a rectangular shape
+ */
+class _ProceduralExport RectangleShape
+{
+	Ogre::Real mWidth,mHeight;
+
+	public:
+	/// Default constructor
+	RectangleShape() : mWidth(1.0), mHeight(1.0) {}
+
+	/// Sets width
+	inline RectangleShape& setWidth(Ogre::Real width)
+	{
+		mWidth = width;
+		return *this;
+	}
+
+	/// Sets height
+	inline RectangleShape& setHeight(Ogre::Real height)
+	{
+		mHeight = height;
+		return *this;
+	}
+
+	/// Builds the shape
+	Shape realizeShape()
+	{
+		Shape s;
+		s.addPoint(-.5f*mWidth,-.5f*mHeight)
+		 .addPoint(.5f*mWidth,-.5f*mHeight)
+		 .addPoint(.5f*mWidth,.5f*mHeight)
+		 .addPoint(-.5f*mWidth,.5f*mHeight)
+		 .close();
+		return s;
+	}
+};
+
+//-----------------------------------------------------------------------
+/**
+ * Builds a circular shape
+ */
+class _ProceduralExport CircleShape
+{
+	Ogre::Real mRadius;
+	unsigned int mNumSeg;
+
+	public:
+	/// Default constructor
+	CircleShape() : mRadius(1.0), mNumSeg(8) {}
+
+	/// Sets radius
+	inline CircleShape& setRadius(Ogre::Real radius)
+	{
+		mRadius = radius;
+		return *this;
+	}
+
+	/// Sets number of segments
+	inline CircleShape& setNumSeg(unsigned int numSeg)
+	{
+		mNumSeg = numSeg;
+		return *this;
+	}
+
+	/// Builds the shape
+	Shape realizeShape()
+	{
+		Shape s;
+		Ogre::Real deltaAngle = Ogre::Math::TWO_PI/(Ogre::Real)mNumSeg;
+		for (unsigned int i = 0; i < mNumSeg; ++i)
+		{
+			s.addPoint(mRadius*cosf(i*deltaAngle), mRadius*sinf(i*deltaAngle));
+		}
+		s.close();
+		return s;
+	}
+};
+//-----------------------------------------------------------------------
+/**
+ * Produces a shape from Cubic Hermite control points
+ */
+class _ProceduralExport RoundedCornerSpline2 : public BaseSpline2<RoundedCornerSpline2>
+{		
+	Ogre::Real mRadius;
+
+	std::vector<Ogre::Vector2> mPoints;	
+	
+public:
+	RoundedCornerSpline2() : mRadius(.1f) {}
+	
+	/// Sets the radius of the corners
+	inline RoundedCornerSpline2& setRadius(Ogre::Real radius)
+	{
+		mRadius = radius;
+		return *this;
+	}
+
+	/// Adds a control point
+	inline RoundedCornerSpline2& addPoint(const Ogre::Vector2& p)
+	{
+		mPoints.push_back(p);
+		return *this;
+	}
+
+	/// Adds a control point
+	inline RoundedCornerSpline2& addPoint(Ogre::Real x, Ogre::Real y)
+	{
+		mPoints.push_back(Ogre::Vector2(x,y));
+		return *this;
+	}
+
+	/// Safely gets a control point
+	inline const Ogre::Vector2& safeGetPoint(unsigned int i) const
+	{
+		if (mClosed)
+			return mPoints[Utils::modulo(i,mPoints.size())];
+		return mPoints[Utils::cap(i,0,mPoints.size()-1)];
+	}
+
+	/**
+	 * Builds a shape from control points
+	 */
+	Shape realizeShape();
+};
+
+
+}
+
+#endif

data/deps/include/OgreProcedural/ProceduralSphereGenerator.h

@@ -0,0 +1,80 @@
+/*
+-----------------------------------------------------------------------------
+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_SPHERE_GENERATOR_INCLUDED
+#define PROCEDURAL_SPHERE_GENERATOR_INCLUDED
+
+#include "ProceduralMeshGenerator.h"
+#include "ProceduralPlatform.h"
+
+namespace Procedural
+{
+/** Builds an UV sphere mesh
+ */
+class _ProceduralExport SphereGenerator : public MeshGenerator<SphereGenerator>
+{
+	Ogre::Real mRadius;
+	unsigned int mNumRings;
+	unsigned int mNumSegments;
+
+public:
+	/// Constructor with arguments
+	SphereGenerator(Ogre::Real radius = 1.f, int numRings = 16, int numSegments = 16) : 
+	  mRadius(radius),mNumRings(numRings), mNumSegments(numSegments)
+
+	{}
+
+	/** Sets the radius of the sphere (default=1) */
+	inline SphereGenerator & setRadius(Ogre::Real radius)
+	{
+		mRadius = radius;
+		return *this;
+	}
+
+	/** Sets the number of rings (default=16) */
+	inline SphereGenerator & setNumRings(unsigned int numRings)
+	{
+		mNumRings = numRings;
+		return *this;
+	}
+
+	/** Sets the number of segments (default=16) */
+	inline SphereGenerator & setNumSegments(unsigned int numSegments)
+	{
+		mNumSegments = numSegments;
+		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

data/deps/include/OgreProcedural/ProceduralSplines.h

@@ -0,0 +1,168 @@
+/*
+-----------------------------------------------------------------------------
+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_SPLINES_INCLUDED
+#define PROCEDURAL_SPLINES_INCLUDED
+
+#include "Ogre.h"
+
+namespace Procedural
+{
+	enum CubicHermiteSplineAutoTangentMode
+	{
+		AT_NONE, AT_STRAIGHT, AT_CATMULL
+	};
+		
+	/**
+	 * Template control point for Cubic Hermite splines.
+	 */
+	template <class T> 
+	struct CubicHermiteSplineControlPoint
+	{
+		/// Position of the control point
+		T position;
+		/// Tangent just before the control point
+		T tangentBefore;
+		/// Tangent just after the control point
+		T tangentAfter;
+		/// Auto tangent mode for the tangent just before the control point
+		CubicHermiteSplineAutoTangentMode autoTangentBefore;
+		/// Auto tangent mode for the tangent just after the control point
+		CubicHermiteSplineAutoTangentMode autoTangentAfter;
+		
+		/// Default constructor
+		CubicHermiteSplineControlPoint() {}
+
+		/// Constructor with arguments
+		CubicHermiteSplineControlPoint(const T& p, const T& before, const T& after) : position(p), tangentBefore(before), tangentAfter(after), autoTangentBefore(AT_NONE), autoTangentAfter(AT_NONE) {}
+	};
+	
+	template <class T>
+	void computeTangents(CubicHermiteSplineControlPoint<T>& point, const T& pointBefore, const T& pointAfter)
+	{
+		switch (point.autoTangentBefore)
+		{
+		case AT_STRAIGHT:
+			point.tangentBefore = point.position - pointBefore;
+			break;
+		case AT_CATMULL:
+			point.tangentBefore = pointAfter - pointBefore;
+			break;
+        case AT_NONE:
+            break;
+		}
+
+		switch (point.autoTangentAfter)
+		{
+		case AT_STRAIGHT:
+			point.tangentAfter = pointAfter - point.position;
+			break;
+		case AT_CATMULL:
+			point.tangentAfter = pointAfter - pointBefore;
+			break;
+        case AT_NONE:
+            break;
+		}
+	}
+	
+	// Computes the Cubic Hermite interpolation between 2 control points
+	// Warning : does not compute auto-tangents, as AUTOTANGENT_CATMULL depend on context
+	// Auto-Tangents should be computed before that call
+	template<class T>
+	void computeCubicHermitePoints(const CubicHermiteSplineControlPoint<T>& pointBefore, const CubicHermiteSplineControlPoint<T>& pointAfter, unsigned int numSeg, std::vector<T>& pointList)
+	{	
+		const T& p0 = pointBefore.position;
+		const T& m0 = pointBefore.tangentAfter;
+		const T& p1 = pointAfter.position;
+		const T& m1 = pointAfter.tangentBefore;
+				
+		for (unsigned int j = 0; j < numSeg; ++j)
+			{
+				Ogre::Real t = (Ogre::Real)j/(Ogre::Real)numSeg;
+				Ogre::Real t2 = t*t;
+				Ogre::Real t3 = t2*t;
+				T P = (2*t3-3*t2+1)*p0+(t3-2*t2+t)*m0+(-2*t3+3*t2)*p1+(t3-t2)*m1;
+				pointList.push_back(P);
+			}
+	}
+
+	template<class T>
+	void computeCatmullRomPoints(const T& P1, const T& P2, const T& P3, const T& P4, unsigned int numSeg, std::vector<T>& pointList)
+	{
+		for (unsigned int j = 0; j < numSeg; ++j)
+			{				
+				Ogre::Real t = (Ogre::Real)j/(Ogre::Real)numSeg;
+				Ogre::Real t2 = t*t;
+				Ogre::Real t3 = t*t2;
+				T P = 0.5f*((-t3+2.f*t2-t)*P1 + (3.f*t3-5.f*t2+2.f)*P2 + (-3.f*t3+4.f*t2+t)*P3 + (t3-t2)*P4);
+				pointList.push_back(P);
+			}
+	}
+
+	/**
+	 * Template control point for KochanekBartels's splines
+	 */
+	template <class T>
+	struct KochanekBartelsSplineControlPoint
+	{
+		/// Position of the control point
+		T position;
+
+		/// Tension of the control point
+		Ogre::Real tension;
+
+		/// Bias of the control point
+		Ogre::Real bias;
+
+		/// Continuity of the control point
+		Ogre::Real continuity;
+		
+		/// Constructor with arguments
+		KochanekBartelsSplineControlPoint(const T& p, Ogre::Real t, Ogre::Real b, Ogre::Real c) : position(p), tension(t), bias(b), continuity(c) {}
+		/// Constructor with tension=bias=continuity=0
+		KochanekBartelsSplineControlPoint(const T& p) : position(p), tension(0.), bias(0.), continuity(0.) {}
+	};
+
+	template<class T>
+	void computeKochanekBartelsPoints(const KochanekBartelsSplineControlPoint<T>& P1, const KochanekBartelsSplineControlPoint<T>& P2, 
+									const KochanekBartelsSplineControlPoint<T>& P3, const KochanekBartelsSplineControlPoint<T>& P4, unsigned int numSeg, std::vector<T>& pointList)
+	{
+		Ogre::Vector2 m0 = (1-P2.tension)*(1+P2.bias)*(1+P2.continuity)/2.f*(P2.position-P1.position)+(1-P2.tension)*(1-P2.bias)*(1-P2.continuity)/2.f*(P3.position-P2.position);
+		Ogre::Vector2 m1 = (1-P3.tension)*(1+P3.bias)*(1-P3.continuity)/2.f*(P3.position-P2.position)+(1-P3.tension)*(1-P3.bias)*(1+P3.continuity)/2.f*(P4.position-P3.position);
+			
+		for (unsigned int j = 0;j < numSeg; ++j)
+		{
+			Ogre::Real t = (Ogre::Real)j/(Ogre::Real)numSeg;
+			Ogre::Real t2 = t*t;
+			Ogre::Real t3 = t2*t;
+			T P = (2*t3-3*t2+1)*P2.position+(t3-2*t2+t)*m0+(-2*t3+3*t2)*P3.position+(t3-t2)*m1;
+			pointList.push_back(P);
+		}
+	}
+}
+
+#endif