ruby-procedural 0.0.1-x86-linux

data/deps/include/OgreProcedural/ProceduralTriangulator.h

@@ -0,0 +1,173 @@
+/*
+-----------------------------------------------------------------------------
+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_TRIANGULATOR_INCLUDED
+#define PROCEDURAL_TRIANGULATOR_INCLUDED
+
+#include "ProceduralTriangleBuffer.h"
+#include "ProceduralShape.h"
+#include "OgreVector3.h"
+#include "OgreMatrix4.h"
+#include "ProceduralUtils.h"
+#include "ProceduralMultiShape.h"
+#include "ProceduralMeshGenerator.h"
+
+namespace Procedural
+{
+typedef std::vector<Ogre::Vector2> PointList;
+
+/** Implements a Delaunay Triangulation algorithm.
+ * It works on Shapes to build Triangle Buffers
+ */
+class _ProceduralExport Triangulator : public MeshGenerator<Triangulator>
+{	
+	struct Triangle;
+	struct DelaunaySegment;
+	typedef std::list<Triangle> DelaunayTriangleBuffer;	
+	
+//-----------------------------------------------------------------------
+struct DelaunaySegment
+{
+	int i1, i2;
+	DelaunaySegment(int _i1, int _i2) : i1(_i1), i2(_i2) {}
+	bool operator<(const DelaunaySegment& other) const
+	{
+		if (i1!=other.i1)
+			return i1<other.i1;
+		else
+			return i2<other.i2;
+	}
+	DelaunaySegment inverse()
+	{
+		return DelaunaySegment(i2, i1);
+	}
+};	
+
+	//-----------------------------------------------------------------------
+struct Triangle
+{
+	const PointList* pl;
+	int i[3];
+	Triangle(const PointList* pl)
+	{	this->pl = pl;
+	}
+
+	inline Ogre::Vector2 p(int k) const
+	{
+		return (*pl)[i[k]];
+	}
+
+	bool operator==(const Triangle& other) const
+	{
+		return i[0]==other.i[0] && i[1]==other.i[1] && i[2]==other.i[2];
+	}
+
+	inline Ogre::Vector2 getMidPoint() const
+	{
+		return 1.f/3.f * (p(0)+p(1)+p(2));
+	}
+	
+	void setVertices(int i0, int i1, int i2);
+
+	int findSegNumber(int i0, int i1) const;
+
+	bool isPointInside(const Ogre::Vector2& point);
+	
+	bool containsSegment(int i0, int i1) const
+	{		
+		return ((i0==i[0] || i0==i[1] || i0==i[2])&&(i1==i[0] || i1==i[1] || i1==i[2]));
+	}
+
+	enum InsideType
+	{
+		IT_INSIDE, IT_OUTSIDE, IT_BORDERLINEOUTSIDE
+	};
+
+	InsideType isPointInsideCircumcircle(const Ogre::Vector2& point);
+
+	void makeDirectIfNeeded()
+	{
+		if ((p(1)-p(0)).crossProduct(p(2)-p(0))<0)
+		{
+			std::swap(i[0], i[1]);
+		}
+	}
+};
+//-----------------------------------------------------------------------
+struct TouchSuperTriangle
+{
+	int i0,i1,i2;
+	TouchSuperTriangle(int i, int j, int k) : i0(i), i1(j), i2(k) {}
+	bool operator()(const Triangulator::Triangle& tri)
+	{
+		for (int k=0;k<3;k++) if (tri.i[k]==i0 || tri.i[k]==i1 ||tri.i[k]==i2) return true;
+		return false;
+	}
+};
+
+	Shape* mShapeToTriangulate;
+	MultiShape* mMultiShapeToTriangulate;
+
+	void delaunay(PointList& pointList, DelaunayTriangleBuffer& tbuffer) const;
+	void addConstraints(const MultiShape& multiShape, DelaunayTriangleBuffer& tbuffer, const PointList& pl) const;
+	void _recursiveTriangulatePolygon(const DelaunaySegment& cuttingSeg, std::vector<int> inputPoints, DelaunayTriangleBuffer& tbuffer, const PointList&  pl) const;
+
+public:	
+
+	/// Default ctor
+	Triangulator() : mShapeToTriangulate(0), mMultiShapeToTriangulate(0) {}
+
+	/// Sets shape to triangulate
+	Triangulator& setShapeToTriangulate(Shape* shape)
+	{
+		mShapeToTriangulate = shape;
+		mMultiShapeToTriangulate = 0;
+		return *this;
+	}
+
+	/// Sets multi shape to triangulate
+	Triangulator& setMultiShapeToTriangulate(MultiShape* multiShape)
+	{
+		mMultiShapeToTriangulate = multiShape;
+		return *this;
+	}
+	
+	/**
+	 * Executes the Constrained Delaunay Triangulation algorithm
+	 * @arg ouput A vector of index where is outputed the resulting triangle indexes
+	 */
+	void triangulate(std::vector<int>& output, PointList& outputVertices) const;
+	
+	/**
+	 * 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/ProceduralTubeGenerator.h

@@ -0,0 +1,96 @@
+/*
+-----------------------------------------------------------------------------
+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_TUBE_GENERATOR_INCLUDED
+#define PROCEDURAL_TUBE_GENERATOR_INCLUDED
+
+#include "ProceduralMeshGenerator.h"
+#include "ProceduralPlatform.h"
+
+namespace Procedural
+{
+/// Builds an Y-axis tube mesh, i.e. an emptied cylinder
+class _ProceduralExport TubeGenerator : public MeshGenerator<TubeGenerator>
+{
+	int mNumSegBase;
+	int mNumSegHeight;
+	Ogre::Real mOuterRadius;
+	Ogre::Real mInnerRadius;
+	Ogre::Real mHeight;
+
+public:
+	/// Constructor with arguments
+	TubeGenerator(Ogre::Real outerRadius=2.f, Ogre::Real innerRadius=1.f, Ogre::Real height=1.f, int numSegBase=16, int numSegHeight=1) : 
+	    mNumSegBase(numSegBase),
+		mNumSegHeight(numSegHeight),
+		mOuterRadius(outerRadius),
+		mInnerRadius(innerRadius),
+		mHeight(height) {}
+
+	/**
+	 * Builds the mesh into the given TriangleBuffer
+	 * @param buffer The TriangleBuffer on where to append the mesh.
+	 */
+	void addToTriangleBuffer(TriangleBuffer& buffer) const;
+
+	/** Sets the number of segments when rotating around the tube's axis (default=16) */	
+	inline TubeGenerator & setNumSegBase(int numSegBase)
+	{
+		mNumSegBase = numSegBase;
+		return *this;
+	}
+
+	/** Sets the number of segments along the height of the cylinder (default=1) */
+	inline TubeGenerator & setNumSegHeight(int numSegHeight)
+	{
+		mNumSegHeight = numSegHeight;
+		return *this;
+	}
+
+	/** Sets the outer radius of the tube (default=2)*/
+	inline TubeGenerator & setOuterRadius(Ogre::Real outerRadius)
+	{
+		mOuterRadius = outerRadius;
+		return *this;
+	}
+
+	/** Sets the inner radius of the tube (default=1)*/
+	inline TubeGenerator & setInnerRadius(Ogre::Real innerRadius)
+	{
+		mInnerRadius = innerRadius;
+		return *this;
+	}
+
+	/** Sets the height of the tube (default=1) */
+	inline TubeGenerator & setHeight(Ogre::Real height)
+	{
+		mHeight = height;
+		return *this;
+	}
+};
+}
+#endif

data/deps/include/OgreProcedural/ProceduralUtils.h

@@ -0,0 +1,185 @@
+/*
+-----------------------------------------------------------------------------
+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_UTILS_INCLUDED
+#define PROCEDURAL_UTILS_INCLUDED
+#include "OgreVector3.h"
+#include "OgreAxisAlignedBox.h"
+#include "ProceduralPlatform.h"
+
+namespace Procedural
+{
+/// Holds a bunch of static utility functions
+class _ProceduralExport Utils
+{
+	static int counter;
+public:
+	/// Outputs something to the ogre log, with a [PROCEDURAL] prefix
+	static void log(const Ogre::String& st)
+	{
+		   Ogre::LogManager::getSingleton().logMessage("[PROCEDURAL] " + st);
+   #if (PROCEDURAL_PLATFORM == PROCEDURAL_PLATFORM_WIN32)      
+      #ifdef UNICODE
+         std::basic_ostringstream<TCHAR> buf;
+         buf << st.c_str();
+         std::wstring wst = buf.str();               
+         OutputDebugString( wst.c_str() );
+      #else
+         OutputDebugString( (st + "\n").c_str() );
+      #endif   
+   #endif
+	}
+
+	/// Gets the min of the coordinates between 2 vectors
+	static Ogre::Vector3 min(const Ogre::Vector3& v1, const Ogre::Vector3& v2)
+	{
+		return Ogre::Vector3(std::min(v1.x, v2.x), std::min(v1.y, v2.y), std::min(v1.z, v2.z));
+	}
+
+	/// Gets the max of the coordinates between 2 vectors
+	static Ogre::Vector3 max(const Ogre::Vector3& v1, const Ogre::Vector3& v2)
+	{
+		return Ogre::Vector3(std::max(v1.x, v2.x), std::max(v1.y, v2.y), std::max(v1.z, v2.z));
+	}
+
+	/// Gets the min of the coordinates between 2 vectors
+	static Ogre::Vector2 min(const Ogre::Vector2& v1, const Ogre::Vector2& v2)
+	{
+		return Ogre::Vector2(std::min(v1.x, v2.x), std::min(v1.y, v2.y));
+	}
+
+	/// Gets the max of the coordinates between 2 vectors
+	static Ogre::Vector2 max(const Ogre::Vector2& v1, const Ogre::Vector2& v2)
+	{
+		return Ogre::Vector2(std::max(v1.x, v2.x), std::max(v1.y, v2.y));
+	}
+
+	/// Builds an AABB from a list of points
+	static Ogre::AxisAlignedBox AABBfromPoints(std::vector<Ogre::Vector3> points)
+	{
+		Ogre::AxisAlignedBox aabb;
+		if (points.size() == 0)
+			return aabb;
+		aabb.setMinimum(points[0]);
+		aabb.setMaximum(points[0]);
+		for (std::vector<Ogre::Vector3>::iterator it = points.begin(); it!=points.end();it++)
+		{
+			aabb.setMinimum(min(aabb.getMinimum(), *it));
+			aabb.setMaximum(max(aabb.getMaximum(), *it));
+		}
+
+		return aabb;
+	}
+
+	/// Generate a name from a prefix and a counter
+	static std::string getName(const std::string& prefix= "default");
+
+	/// Shifts the components of the vector to the right
+	static Ogre::Vector3 vectorPermute(const Ogre::Vector3& in)
+	{
+		return Ogre::Vector3(in.z, in.x, in.y);
+	}
+
+	/// Shifts the components of the vector to the left
+	static Ogre::Vector3 vectorAntiPermute(const Ogre::Vector3& in)
+	{
+		return Ogre::Vector3(in.y, in.z, in.x);
+	}
+
+	// Rotates a Vector2 by a given oriented angle
+	static inline Ogre::Vector2 rotateVector2(const Ogre::Vector2& in, Ogre::Radian angle)
+	{
+		return Ogre::Vector2(in.x* Ogre::Math::Cos(angle) - in.y * Ogre::Math::Sin(angle),
+			in.x * Ogre::Math::Sin(angle) + in.y * Ogre::Math::Cos(angle));
+	}
+	
+	/// Caps n between min and max
+	static int cap(int n, int min, int max)
+	{
+		return std::max(std::min(n,max),min);
+	}
+
+	/**
+	 * An extend version of the standard modulo, in that int values are "wrapped"
+	 * in both directions, whereas with standard modulo, (-1)%2 == -1
+	 * Always return an int between 0 and cap-1
+	 */
+	static int modulo(int n, int cap)
+	{
+		if (n>=0)
+			return n%cap;
+		return (cap-1)-((1+n)%cap);
+	}
+
+	/**
+	 * Equivalent of Ogre::Vector3::angleBetween, applied to Ogre::Vector2
+	 */
+	static inline Ogre::Radian angleBetween(const Ogre::Vector2& v1, const Ogre::Vector2& v2)
+	{		
+		Ogre::Real lenProduct = v1.length() * v2.length();
+		// Divide by zero check
+		if(lenProduct < 1e-6f)
+			lenProduct = 1e-6f;
+		
+		Ogre::Real f = v1.dotProduct(v2) / lenProduct;
+	
+		f = Ogre::Math::Clamp(f, (Ogre::Real)-1.0, (Ogre::Real)1.0);
+		return Ogre::Math::ACos(f);
+	}
+
+	/**
+	 * Gives the oriented angle from v1 to v2
+	 */
+	static inline Ogre::Radian angleTo(const Ogre::Vector2& v1, const Ogre::Vector2& v2)
+	{
+		Ogre::Radian angle = angleBetween(v1, v2);
+		
+		if (v1.crossProduct(v2)<0)
+		{
+			angle = (Ogre::Radian)Ogre::Math::TWO_PI - angle;
+		}
+
+		return angle;
+	}
+
+	/**
+	 * Computes a quaternion between UNIT_Z and direction.
+	 * It keeps the "up" vector to UNIT_Y
+	 */
+	static Ogre::Quaternion _computeQuaternion(const Ogre::Vector3& direction, const Ogre::Vector3& upVector = Ogre::Vector3::UNIT_Y);
+
+	/**
+	 * Maps a vector2 to vector3, with Y=0
+	 */
+	static inline Ogre::Vector3 vec2ToVec3Y(const Ogre::Vector2& pos)
+	{
+		return Ogre::Vector3(pos.x, 0, pos.y);
+	}
+	
+};
+}
+#endif