ruby-bullet 0.1.0-x86-linux → 0.1.1-x86-linux

data/deps/include/bullet/LinearMath/btConvexHull.h

@@ -1,241 +0,0 @@
-
-/*
-Stan Melax Convex Hull Computation
-Copyright (c) 2008 Stan Melax http://www.melax.com/
-
-This software is provided 'as-is', without any express or implied warranty.
-In no event will the authors be held liable for any damages arising from the use of this software.
-Permission is granted to anyone to use this software for any purpose, 
-including commercial applications, and to alter it and redistribute it freely, 
-subject to the following restrictions:
-
-1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
-2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
-3. This notice may not be removed or altered from any source distribution.
-*/
-
-///includes modifications/improvements by John Ratcliff, see BringOutYourDead below.
-
-#ifndef BT_CD_HULL_H
-#define BT_CD_HULL_H
-
-#include "btVector3.h"
-#include "btAlignedObjectArray.h"
-
-typedef btAlignedObjectArray<unsigned int> TUIntArray;
-
-class HullResult
-{
-public:
-	HullResult(void)
-	{
-		mPolygons = true;
-		mNumOutputVertices = 0;
-		mNumFaces = 0;
-		mNumIndices = 0;
-	}
-	bool                    mPolygons;                  // true if indices represents polygons, false indices are triangles
-	unsigned int            mNumOutputVertices;         // number of vertices in the output hull
-	btAlignedObjectArray<btVector3>	m_OutputVertices;            // array of vertices
-	unsigned int            mNumFaces;                  // the number of faces produced
-	unsigned int            mNumIndices;                // the total number of indices
-	btAlignedObjectArray<unsigned int>    m_Indices;                   // pointer to indices.
-
-// If triangles, then indices are array indexes into the vertex list.
-// If polygons, indices are in the form (number of points in face) (p1, p2, p3, ..) etc..
-};
-
-enum HullFlag
-{
-	QF_TRIANGLES         = (1<<0),             // report results as triangles, not polygons.
-	QF_REVERSE_ORDER     = (1<<1),             // reverse order of the triangle indices.
-	QF_DEFAULT           = QF_TRIANGLES
-};
-
-
-class HullDesc
-{
-public:
-	HullDesc(void)
-	{
-		mFlags          = QF_DEFAULT;
-		mVcount         = 0;
-		mVertices       = 0;
-		mVertexStride   = sizeof(btVector3);
-		mNormalEpsilon  = 0.001f;
-		mMaxVertices	= 4096; // maximum number of points to be considered for a convex hull.
-		mMaxFaces	= 4096;
-	};
-
-	HullDesc(HullFlag flag,
-		 unsigned int vcount,
-		 const btVector3 *vertices,
-		 unsigned int stride = sizeof(btVector3))
-	{
-		mFlags          = flag;
-		mVcount         = vcount;
-		mVertices       = vertices;
-		mVertexStride   = stride;
-		mNormalEpsilon  = btScalar(0.001);
-		mMaxVertices    = 4096;
-	}
-
-	bool HasHullFlag(HullFlag flag) const
-	{
-		if ( mFlags & flag ) return true;
-		return false;
-	}
-
-	void SetHullFlag(HullFlag flag)
-	{
-		mFlags|=flag;
-	}
-
-	void ClearHullFlag(HullFlag flag)
-	{
-		mFlags&=~flag;
-	}
-
-	unsigned int      mFlags;           // flags to use when generating the convex hull.
-	unsigned int      mVcount;          // number of vertices in the input point cloud
-	const btVector3  *mVertices;        // the array of vertices.
-	unsigned int      mVertexStride;    // the stride of each vertex, in bytes.
-	btScalar             mNormalEpsilon;   // the epsilon for removing duplicates.  This is a normalized value, if normalized bit is on.
-	unsigned int      mMaxVertices;     // maximum number of vertices to be considered for the hull!
-	unsigned int      mMaxFaces;
-};
-
-enum HullError
-{
-	QE_OK,            // success!
-	QE_FAIL           // failed.
-};
-
-class btPlane
-{
-	public:
-	btVector3	normal;
-	btScalar	dist;   // distance below origin - the D from plane equasion Ax+By+Cz+D=0
-			btPlane(const btVector3 &n,btScalar d):normal(n),dist(d){}
-			btPlane():normal(),dist(0){}
-	
-};
-
-
-
-class ConvexH 
-{
-  public:
-	class HalfEdge
-	{
-	  public:
-		short ea;         // the other half of the edge (index into edges list)
-		unsigned char v;  // the vertex at the start of this edge (index into vertices list)
-		unsigned char p;  // the facet on which this edge lies (index into facets list)
-		HalfEdge(){}
-		HalfEdge(short _ea,unsigned char _v, unsigned char _p):ea(_ea),v(_v),p(_p){}
-	};
-	ConvexH()
-	{
-	}
-	~ConvexH()
-	{
-	}
-	btAlignedObjectArray<btVector3> vertices;
-	btAlignedObjectArray<HalfEdge> edges;
-	btAlignedObjectArray<btPlane>  facets;
-	ConvexH(int vertices_size,int edges_size,int facets_size);
-};
-
-
-class int4
-{
-public:
-	int x,y,z,w;
-	int4(){};
-	int4(int _x,int _y, int _z,int _w){x=_x;y=_y;z=_z;w=_w;}
-	const int& operator[](int i) const {return (&x)[i];}
-	int& operator[](int i) {return (&x)[i];}
-};
-
-class PHullResult
-{
-public:
-
-	PHullResult(void)
-	{
-		mVcount = 0;
-		mIndexCount = 0;
-		mFaceCount = 0;
-		mVertices = 0;
-	}
-
-	unsigned int mVcount;
-	unsigned int mIndexCount;
-	unsigned int mFaceCount;
-	btVector3*   mVertices;
-	TUIntArray m_Indices;
-};
-
-
-
-///The HullLibrary class can create a convex hull from a collection of vertices, using the ComputeHull method.
-///The btShapeHull class uses this HullLibrary to create a approximate convex mesh given a general (non-polyhedral) convex shape.
-class HullLibrary
-{
-
-	btAlignedObjectArray<class btHullTriangle*> m_tris;
-
-public:
-
-	btAlignedObjectArray<int> m_vertexIndexMapping;
-
-
-	HullError CreateConvexHull(const HullDesc& desc, // describes the input request
-				   HullResult&     result);        // contains the resulst
-	HullError ReleaseResult(HullResult &result); // release memory allocated for this result, we are done with it.
-
-private:
-
-	bool ComputeHull(unsigned int vcount,const btVector3 *vertices,PHullResult &result,unsigned int vlimit);
-
-	class btHullTriangle*	allocateTriangle(int a,int b,int c);
-	void	deAllocateTriangle(btHullTriangle*);
-	void b2bfix(btHullTriangle* s,btHullTriangle*t);
-
-	void removeb2b(btHullTriangle* s,btHullTriangle*t);
-
-	void checkit(btHullTriangle *t);
-
-	btHullTriangle* extrudable(btScalar epsilon);
-
-	int calchull(btVector3 *verts,int verts_count, TUIntArray& tris_out, int &tris_count,int vlimit);
-
-	int calchullgen(btVector3 *verts,int verts_count, int vlimit);
-
-	int4 FindSimplex(btVector3 *verts,int verts_count,btAlignedObjectArray<int> &allow);
-
-	class ConvexH* ConvexHCrop(ConvexH& convex,const btPlane& slice);
-
-	void extrude(class btHullTriangle* t0,int v);
-
-	ConvexH* test_cube();
-
-	//BringOutYourDead (John Ratcliff): When you create a convex hull you hand it a large input set of vertices forming a 'point cloud'. 
-	//After the hull is generated it give you back a set of polygon faces which index the *original* point cloud.
-	//The thing is, often times, there are many 'dead vertices' in the point cloud that are on longer referenced by the hull.
-	//The routine 'BringOutYourDead' find only the referenced vertices, copies them to an new buffer, and re-indexes the hull so that it is a minimal representation.
-	void BringOutYourDead(const btVector3* verts,unsigned int vcount, btVector3* overts,unsigned int &ocount,unsigned int* indices,unsigned indexcount);
-
-	bool CleanupVertices(unsigned int svcount,
-			     const btVector3* svertices,
-			     unsigned int stride,
-			     unsigned int &vcount, // output number of vertices
-			     btVector3* vertices, // location to store the results.
-			     btScalar  normalepsilon,
-			     btVector3& scale);
-};
-
-
-#endif //BT_CD_HULL_H
-

data/deps/include/bullet/LinearMath/btConvexHullComputer.h

@@ -1,103 +0,0 @@
-/*
-Copyright (c) 2011 Ole Kniemeyer, MAXON, www.maxon.net
-
-This software is provided 'as-is', without any express or implied warranty.
-In no event will the authors be held liable for any damages arising from the use of this software.
-Permission is granted to anyone to use this software for any purpose, 
-including commercial applications, and to alter it and redistribute it freely, 
-subject to the following restrictions:
-
-1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
-2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
-3. This notice may not be removed or altered from any source distribution.
-*/
-
-#ifndef BT_CONVEX_HULL_COMPUTER_H
-#define BT_CONVEX_HULL_COMPUTER_H
-
-#include "btVector3.h"
-#include "btAlignedObjectArray.h"
-
-/// Convex hull implementation based on Preparata and Hong
-/// See http://code.google.com/p/bullet/issues/detail?id=275
-/// Ole Kniemeyer, MAXON Computer GmbH
-class btConvexHullComputer
-{
-	private:
-		btScalar compute(const void* coords, bool doubleCoords, int stride, int count, btScalar shrink, btScalar shrinkClamp);
-
-	public:
-
-		class Edge
-		{
-			private:
-				int next;
-				int reverse;
-				int targetVertex;
-
-				friend class btConvexHullComputer;
-
-			public:
-				int getSourceVertex() const
-				{
-					return (this + reverse)->targetVertex;
-				}
-
-				int getTargetVertex() const
-				{
-					return targetVertex;
-				}
-
-				const Edge* getNextEdgeOfVertex() const // clockwise list of all edges of a vertex
-				{
-					return this + next;
-				}
-
-				const Edge* getNextEdgeOfFace() const // counter-clockwise list of all edges of a face
-				{
-					return (this + reverse)->getNextEdgeOfVertex();
-				}
-
-				const Edge* getReverseEdge() const
-				{
-					return this + reverse;
-				}
-		};
-
-
-		// Vertices of the output hull
-		btAlignedObjectArray<btVector3> vertices;
-
-		// Edges of the output hull
-		btAlignedObjectArray<Edge> edges;
-
-		// Faces of the convex hull. Each entry is an index into the "edges" array pointing to an edge of the face. Faces are planar n-gons
-		btAlignedObjectArray<int> faces;
-
-		/*
-		Compute convex hull of "count" vertices stored in "coords". "stride" is the difference in bytes
-		between the addresses of consecutive vertices. If "shrink" is positive, the convex hull is shrunken
-		by that amount (each face is moved by "shrink" length units towards the center along its normal).
-		If "shrinkClamp" is positive, "shrink" is clamped to not exceed "shrinkClamp * innerRadius", where "innerRadius"
-		is the minimum distance of a face to the center of the convex hull.
-
-		The returned value is the amount by which the hull has been shrunken. If it is negative, the amount was so large
-		that the resulting convex hull is empty.
-
-		The output convex hull can be found in the member variables "vertices", "edges", "faces".
-		*/
-		btScalar compute(const float* coords, int stride, int count, btScalar shrink, btScalar shrinkClamp)
-		{
-			return compute(coords, false, stride, count, shrink, shrinkClamp);
-		}
-
-		// same as above, but double precision
-		btScalar compute(const double* coords, int stride, int count, btScalar shrink, btScalar shrinkClamp)
-		{
-			return compute(coords, true, stride, count, shrink, shrinkClamp);
-		}
-};
-
-
-#endif //BT_CONVEX_HULL_COMPUTER_H
-

data/deps/include/bullet/LinearMath/btDefaultMotionState.h

@@ -1,40 +0,0 @@
-#ifndef BT_DEFAULT_MOTION_STATE_H
-#define BT_DEFAULT_MOTION_STATE_H
-
-#include "btMotionState.h"
-
-///The btDefaultMotionState provides a common implementation to synchronize world transforms with offsets.
-struct	btDefaultMotionState : public btMotionState
-{
-	btTransform m_graphicsWorldTrans;
-	btTransform	m_centerOfMassOffset;
-	btTransform m_startWorldTrans;
-	void*		m_userPointer;
-
-	btDefaultMotionState(const btTransform& startTrans = btTransform::getIdentity(),const btTransform& centerOfMassOffset = btTransform::getIdentity())
-		: m_graphicsWorldTrans(startTrans),
-		m_centerOfMassOffset(centerOfMassOffset),
-		m_startWorldTrans(startTrans),
-		m_userPointer(0)
-
-	{
-	}
-
-	///synchronizes world transform from user to physics
-	virtual void	getWorldTransform(btTransform& centerOfMassWorldTrans ) const 
-	{
-			centerOfMassWorldTrans = 	m_centerOfMassOffset.inverse() * m_graphicsWorldTrans ;
-	}
-
-	///synchronizes world transform from physics to user
-	///Bullet only calls the update of worldtransform for active objects
-	virtual void	setWorldTransform(const btTransform& centerOfMassWorldTrans)
-	{
-			m_graphicsWorldTrans = centerOfMassWorldTrans * m_centerOfMassOffset ;
-	}
-
-	
-
-};
-
-#endif //BT_DEFAULT_MOTION_STATE_H

data/deps/include/bullet/LinearMath/btGeometryUtil.h

@@ -1,42 +0,0 @@
-/*
-Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans  http://continuousphysics.com/Bullet/
-
-This software is provided 'as-is', without any express or implied warranty.
-In no event will the authors be held liable for any damages arising from the use of this software.
-Permission is granted to anyone to use this software for any purpose, 
-including commercial applications, and to alter it and redistribute it freely, 
-subject to the following restrictions:
-
-1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
-2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
-3. This notice may not be removed or altered from any source distribution.
-*/
-
-
-#ifndef BT_GEOMETRY_UTIL_H
-#define BT_GEOMETRY_UTIL_H
-
-#include "btVector3.h"
-#include "btAlignedObjectArray.h"
-
-///The btGeometryUtil helper class provides a few methods to convert between plane equations and vertices.
-class btGeometryUtil
-{
-	public:
-	
-	
-		static void	getPlaneEquationsFromVertices(btAlignedObjectArray<btVector3>& vertices, btAlignedObjectArray<btVector3>& planeEquationsOut );
-
-		static void	getVerticesFromPlaneEquations(const btAlignedObjectArray<btVector3>& planeEquations , btAlignedObjectArray<btVector3>& verticesOut );
-	
-		static bool	isInside(const btAlignedObjectArray<btVector3>& vertices, const btVector3& planeNormal, btScalar	margin);
-		
-		static bool	isPointInsidePlanes(const btAlignedObjectArray<btVector3>& planeEquations, const btVector3& point, btScalar	margin);
-
-		static bool	areVerticesBehindPlane(const btVector3& planeNormal, const btAlignedObjectArray<btVector3>& vertices, btScalar	margin);
-
-};
-
-
-#endif //BT_GEOMETRY_UTIL_H
-

data/deps/include/bullet/LinearMath/btGrahamScan2dConvexHull.h

@@ -1,110 +0,0 @@
-/*
-Bullet Continuous Collision Detection and Physics Library
-Copyright (c) 2011 Advanced Micro Devices, Inc.  http://bulletphysics.org
-
-This software is provided 'as-is', without any express or implied warranty.
-In no event will the authors be held liable for any damages arising from the use of this software.
-Permission is granted to anyone to use this software for any purpose, 
-including commercial applications, and to alter it and redistribute it freely, 
-subject to the following restrictions:
-
-1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
-2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
-3. This notice may not be removed or altered from any source distribution.
-*/
-
-
-#ifndef GRAHAM_SCAN_2D_CONVEX_HULL_H
-#define GRAHAM_SCAN_2D_CONVEX_HULL_H
-
-
-#include "btVector3.h"
-#include "btAlignedObjectArray.h"
-
-struct GrahamVector2 : public btVector3
-{
-	GrahamVector2(const btVector3& org, int orgIndex)
-		:btVector3(org),
-			m_orgIndex(orgIndex)
-	{
-	}
-	btScalar	m_angle;
-	int m_orgIndex;
-};
-
-
-struct btAngleCompareFunc {
-	btVector3 m_anchor;
-	btAngleCompareFunc(const btVector3& anchor)
-	: m_anchor(anchor) 
-	{
-	}
-	bool operator()(const GrahamVector2& a, const GrahamVector2& b) const {
-		if (a.m_angle != b.m_angle)
-			return a.m_angle < b.m_angle;
-		else
-		{
-			btScalar al = (a-m_anchor).length2();
-			btScalar bl = (b-m_anchor).length2();
-			if (al != bl)
-				return  al < bl;
-			else
-			{
-				return a.m_orgIndex < b.m_orgIndex;
-			}
-		}
-	}
-};
-
-inline void GrahamScanConvexHull2D(btAlignedObjectArray<GrahamVector2>& originalPoints, btAlignedObjectArray<GrahamVector2>& hull)
-{
-	if (originalPoints.size()<=1)
-	{
-		for (int i=0;i<originalPoints.size();i++)
-			hull.push_back(originalPoints[0]);
-		return;
-	}
-	//step1 : find anchor point with smallest x/y and move it to first location
-	//also precompute angles
-	for (int i=0;i<originalPoints.size();i++)
-	{
-		const btVector3& left = originalPoints[i];
-		const btVector3& right = originalPoints[0];
-		if (left.x() < right.x() || !(right.x() < left.x()) && left.y() < right.y())
-		{
-			originalPoints.swap(0,i);
-		}
-	}
-
-	for (int i=0;i<originalPoints.size();i++)
-	{
-		btVector3 xvec(1,0,0);
-		btVector3 ar = originalPoints[i]-originalPoints[0];
-		originalPoints[i].m_angle = btCross(xvec, ar).dot(btVector3(0,0,1)) / ar.length();
-	}
-
-	//step 2: sort all points, based on 'angle' with this anchor
-	btAngleCompareFunc comp(originalPoints[0]);
-	originalPoints.quickSortInternal(comp,1,originalPoints.size()-1);
-
-	int i;
-	for (i = 0; i<2; i++) 
-		hull.push_back(originalPoints[i]);
-
-	//step 3: keep all 'convex' points and discard concave points (using back tracking)
-	for (; i != originalPoints.size(); i++) 
-	{
-		bool isConvex = false;
-		while (!isConvex&& hull.size()>1) {
-			btVector3& a = hull[hull.size()-2];
-			btVector3& b = hull[hull.size()-1];
-			isConvex = btCross(a-b,a-originalPoints[i]).dot(btVector3(0,0,1))> 0;
-			if (!isConvex)
-				hull.pop_back();
-			else 
-				hull.push_back(originalPoints[i]);
-		}
-	}
-}
-
-#endif //GRAHAM_SCAN_2D_CONVEX_HULL_H