teienlib 0.0.1-x86-linux

data/ext/teienlib/src/Collision.h

@@ -0,0 +1,130 @@
+#ifndef COLLISION_H
+#define COLLISION_H
+
+#include <map>
+#include <deque>
+#include <utility>
+#include <string>
+
+class Entity;
+
+/**
+ * Collision library:
+ *
+ * This code is based on an excelent book, called Real-Time Collision Detection.
+ */
+
+
+#include "Shape.h"
+
+/// ��ư��Ʊ�Τξ���Ƚ�ꡣ�ߤޤäƤƤ⤤����
+/**
+ * �����˽񤯤٤������ȤǤϤʤ������񤯤Ȥ�������ޤ�ޤǤ����˵�����
+ *
+ * ���Υ��饹�η�ޤ��:
+ *	t�Ͼ�� 0 <= t <= 1
+ *	���äơ�������ֶ�� dt �Ǥθ򺹤������
+ *	V��Ĵ�����롣V = Vorg * dt
+ *
+ *	Moving intersect��vel�ϡ�
+ *	shapeB��®�٤�0�ˤ��롣�Ĥޤ�
+ *	Vel = A.vel - B.vel
+ *	V��Ĵ����
+ */
+
+namespace scl{
+
+class Collision
+{
+public:
+	Collision();
+	virtual ~Collision();
+	
+	void setDebug(bool aBool){ debug = aBool; }
+	
+	/// Moving intersetct wrapper
+	/**
+	 * 1. ®�٤κ�ʬ��ȤꡢshapeB��ߤᡢshapeA������®�٤Τߤˤ��롣
+	 * 2. ®�٤����Ĥ�Ʊ̾�ؿ���Ƥ�
+	 */
+	bool intersectMovingShapes(Shape* shapeA, Vector3D<float> velA,
+							   Shape* shapeB, Vector3D<float> velB,
+							   float delta, float *t);
+	/// Moving intersect
+	/**
+	 * 1. ������Ƚ�̤��롣
+	 * 2. �����ϰϤ�1�ˤ��뤿��ˡ�®�٤��ѹ�����(delta�ܤ���)��
+	 * 3. �����˹�碌��ɾ���ؿ���Ƥ֡�
+	 */
+	bool intersectMovingShapes(Shape* shapeA, Vector3D<float> vel,
+							   Shape* shapeB, 
+							   float delta, float *t);
+	
+	//
+	// Basic collision function
+	//
+	
+	// Test
+	bool testAABBAABB(AABB boxA, AABB boxB);
+	
+	// Closest Point
+	void  closestPtSegment(Segment sg, Vector3D<float> aPos, Vector3D<float> *aXPos);
+	float closestPtSegmentSegment(Segment sg1, Segment sg2,
+								  float *s, float *t, 
+								  Vector3D<float> *c1, Vector3D<float> *c2);
+	// Intersect
+	/** 
+	 * Ray intersetct
+	 * ray = p + dir * t
+	 * colP = dir * t
+	 */
+	bool intersectRayPlane(Vector3D<float> p, Vector3D<float> dir, Plane pl,
+						   float *t, Vector3D<float> *colP);
+	bool intersectRayAABB(Vector3D<float> p, Vector3D<float> dir, AABB box,
+						  float *dist, Vector3D<float> *colP);
+	bool intersectRaySphere(Vector3D<float> p, Vector3D<float> dir, Sphere sp,
+							float *t, Vector3D<float> *colP);
+	
+	/**
+	 * 1. 0 <= *t <= 1
+	 * 2. ���ͤޤǤε�Υ�� seg.len() * (*t)
+	 */
+	bool intersectSegmentSphere(Segment seg, Sphere sp, float *t);
+	bool intersectSegmentCapsule(Segment sg, Capsule cap, float *t);
+	
+private:
+	typedef bool (Collision::*ColFuncPtr)(Shape*, Vector3D<float>, Shape*, float *);
+	typedef std::map<pair<std::string, std::string>, ColFuncPtr> ColMap;
+	
+	pair<std::string, std::string> makeStringPair(const char *s1, const char *s2);
+	
+	ColMap* initCollisionMap();
+	ColFuncPtr lookup(const std::string & classA, const std::string & classB);
+	
+	// Shape���������顢�������ɲ�
+	
+	bool intersectMovingSphereSphere(Shape* sphereA, Vector3D<float> vel, Shape* sphereB, float *t);
+	bool intersectMovingSpherePlane(Shape* sphere, Vector3D<float> vel, Shape* plane, float *t);
+	bool intersectMovingSphereAABB(Shape* sphere, Vector3D<float> vel, Shape* aabb, float *t);
+	bool intersectMovingAABBAABB(Shape* aabbA, Vector3D<float> vel, Shape* aabbB, float *t);
+	bool intersectMovingAABBPlane(Shape* aabb, Vector3D<float> vel, Shape* plane, float *t);
+	bool intersectMovingPlanePlane(Shape* planeA, Vector3D<float> vel, Shape* planeB, float *t);
+	
+	bool intersectMovingPlaneSphere(Shape* pl, Vector3D<float> vel, Shape* sp, float *t)
+	{
+		return intersectMovingSpherePlane(sp, -vel, pl, t);	
+	}
+	bool intersectMovingAABBSphere(Shape* box, Vector3D<float> vel, Shape* sp, float *t)
+	{
+		return intersectMovingSphereAABB(sp, -vel, box, t);
+	}
+	bool intersectMovingPlaneAABB(Shape* pl, Vector3D<float> vel, Shape* box, float *t)
+	{
+		return intersectMovingAABBPlane(box, -vel, pl, t);
+	}
+	
+	bool debug;
+};
+
+}
+#endif

data/ext/teienlib/src/CollisionChecker.cc

@@ -0,0 +1,67 @@
+#include "CollisionChecker.h"
+
+bool
+CollisionChecker::intersectMovingShapes(btCollisionShape* shapeA, 
+					btVector3 posA,
+					btVector3 velA,
+					btCollisionShape* shapeB, 
+					btVector3 posB,
+					btVector3 velB,
+					float delta)
+{
+	float t;
+	return col.intersectMovingShapes(convertShape(shapeA, posA),
+					 convertVector(velA),
+					 convertShape(shapeB, posB),
+					 convertVector(velB),
+					 delta, &t);
+}
+
+
+bool 
+CollisionChecker::intersectRayAABB(btVector3 p, btVector3 dir, 
+				   btBoxShape* box, btVector3 pos,
+				   btVector3* colP)
+{
+	float t;
+	sul::Vector3D<float> xPt;
+	bool bl =  col.intersectRayAABB(convertVector(p),
+					convertVector(dir),
+					*(scl::AABB*)convertShape(box, pos),
+					&t, &xPt);
+	colP->setValue(xPt.x, xPt.y, xPt.z);
+	return bl;
+}
+
+void
+CollisionChecker::closestPtSegment(btVector3 segA, btVector3 segB, 
+				   btVector3 pos, btVector3* colP)
+{
+	sul::Vector3D<float> xPt;
+	col.closestPtSegment(scl::Segment(convertVector(segA), convertVector(segB)),
+			     convertVector(pos),  &xPt);
+	colP->setValue(xPt.x, xPt.y, xPt.z);
+}
+
+
+scl::Shape*
+CollisionChecker::convertShape(btCollisionShape* btShape, btVector3 btPos)
+{
+	if (btBoxShape* btBox = dynamic_cast<btBoxShape*>(btShape)) {
+		scl::AABB* shape = new scl::AABB();
+		shape->setPos(convertVector(btPos), 
+			      convertVector(btBox->getHalfExtentsWithMargin()));
+		return shape;
+	}
+	else {
+		std::cerr << __PRETTY_FUNCTION__ << ": This shape is not supported." << std::endl;
+		return NULL;
+	}
+}
+
+
+sul::Vector3D<float>
+CollisionChecker::convertVector(btVector3 btVec)
+{
+	return sul::Vector3D<float>(btVec.x(), btVec.y(), btVec.z());
+}

data/ext/teienlib/src/CollisionChecker.h

@@ -0,0 +1,33 @@
+#ifndef __CollisionChecker_h__
+#define __CollisionChecker_h__
+
+#include "Collision.h"
+#include <btBulletCollisionCommon.h>
+
+class CollisionChecker
+{
+public:
+	bool intersectMovingShapes(btCollisionShape* shapeA, 
+				   btVector3 posA,
+				   btVector3 velA,
+				   btCollisionShape* shapeB, 
+				   btVector3 posB,
+				   btVector3 velB,
+				   float delta);	
+
+
+	bool intersectRayAABB(btVector3 p, btVector3 dir, 
+			      btBoxShape* box, btVector3 pos,
+			      btVector3* colP);
+
+	void closestPtSegment(btVector3 segA, btVector3 segB, 
+			      btVector3 pos, btVector3* xPt);
+
+	scl::Shape* convertShape(btCollisionShape* btShape, btVector3 btPos);
+	sul::Vector3D<float> convertVector(btVector3 btVec);
+
+private:
+	scl::Collision col;
+};
+
+#endif

data/ext/teienlib/src/DebugDrawer.h

@@ -0,0 +1,66 @@
+/*
+ * The class is a snippet of http://www.ogre3d.org/tikiwiki/BulletDebugDrawer&structure=Cookbook.
+ */
+
+#ifndef DebugDrawer_h__
+#define DebugDrawer_h__
+ 
+//#include "../common.h"
+
+#include <Ogre.h>
+#include <btBulletDynamicsCommon.h>
+ 
+class DebugDrawer: public btIDebugDraw, public Ogre::FrameListener{
+public:
+	DebugDrawer( Ogre::SceneManager *scm );
+	~DebugDrawer ();
+	virtual void drawLine (const btVector3 &from, const btVector3 &to, const btVector3 &color);
+	virtual void drawTriangle (const btVector3 &v0, const btVector3 &v1, const btVector3 &v2, 
+				   const btVector3 &color, btScalar);
+	virtual void drawContactPoint (const btVector3 &PointOnB, const btVector3 &normalOnB, 
+				       btScalar distance, int lifeTime, const btVector3 &color);
+	virtual void reportErrorWarning (const char *warningString);
+	virtual void draw3dText (const btVector3 &location, const char *textString);
+	virtual void setDebugMode (int debugMode);
+	virtual int  getDebugMode () const;
+protected:
+	bool frameStarted(const Ogre::FrameEvent& evt);
+	void callBegin();
+//	bool frameRenderingQueued (const Ogre::FrameEvent &evt);
+//	bool frameEnded(const Ogre::FrameEvent& evt);
+private:
+	struct ContactPoint{
+		Ogre::Vector3 from;
+		Ogre::Vector3 to;
+		Ogre::ColourValue   color;
+		size_t        dieTime;
+	};
+	DebugDrawModes               mDebugModes;
+	Ogre::ManualObject          *mLines;
+	Ogre::ManualObject          *mTriangles;
+	std::vector< ContactPoint > *mContactPoints;
+	std::vector< ContactPoint >  mContactPoints1;
+	std::vector< ContactPoint >  mContactPoints2;
+
+	bool mRequestBegin;
+};
+
+inline btVector3 cvt(const Ogre::Vector3 &V){
+    return btVector3(V.x, V.y, V.z);
+}
+ 
+inline Ogre::Vector3 cvt(const btVector3&V){
+    return Ogre::Vector3(V.x(), V.y(), V.z());
+}
+ 
+inline btQuaternion cvt(const Ogre::Quaternion &Q)
+{
+    return btQuaternion(Q.x, Q.y, Q.z, Q.w);
+};
+ 
+inline Ogre::Quaternion cvt(const btQuaternion &Q)
+{
+    return Ogre::Quaternion(Q.w(), Q.x(), Q.y(), Q.z());
+};
+
+#endif // DebugDrawer_h__

data/ext/teienlib/src/MeshStrider.cc

@@ -0,0 +1,112 @@
+#include "MeshStrider.h"
+
+int MeshStrider::getNumSubParts() const
+{
+    int ret = mMesh->getNumSubMeshes();
+    ASSERT( ret > 0 );
+    return ret;
+}
+ 
+void MeshStrider::getLockedReadOnlyVertexIndexBase( 
+    const unsigned char **vertexbase, 
+    int& numverts,
+    PHY_ScalarType& type, 
+    int& stride,
+    const unsigned char **indexbase,
+    int & indexstride,
+    int& numfaces,
+    PHY_ScalarType& indicestype,
+    int subpart/*=0*/ ) const
+{
+	Ogre::SubMesh* submesh = mMesh->getSubMesh(subpart);
+	Ogre::VertexData* vertex_data = submesh->useSharedVertices ? mMesh->sharedVertexData : submesh->vertexData;
+	
+	const Ogre::VertexElement* posElem =
+		vertex_data->vertexDeclaration->findElementBySemantic(Ogre::VES_POSITION);
+	
+	Ogre::HardwareVertexBufferSharedPtr vbuf =
+		vertex_data->vertexBufferBinding->getBuffer(posElem->getSource());
+ 
+	*vertexbase = reinterpret_cast<unsigned char*>(vbuf->lock(Ogre::HardwareBuffer::HBL_READ_ONLY));
+	// There is _no_ baseVertexPointerToElement() which takes an Ogre::Real or a double
+	//  as second argument. So make it float, to avoid trouble when Ogre::Real will
+	//  be comiled/typedefed as double:
+	//Ogre::Real* pReal;
+	float* pReal;
+	posElem->baseVertexPointerToElement((void*) *vertexbase, &pReal);
+	*vertexbase = (unsigned char*) pReal;
+ 
+	stride = (int) vbuf->getVertexSize();
+ 
+	numverts = (int) vertex_data->vertexCount;
+	ASSERT( numverts );
+ 
+	type = PHY_FLOAT;
+ 
+	Ogre::IndexData* index_data = submesh->indexData;
+	Ogre::HardwareIndexBufferSharedPtr ibuf = index_data->indexBuffer;
+ 
+	if (ibuf->getType() == Ogre::HardwareIndexBuffer::IT_32BIT){
+		indicestype = PHY_INTEGER;
+	}
+	else{
+		ASSERT(ibuf->getType() == Ogre::HardwareIndexBuffer::IT_16BIT);
+		indicestype = PHY_SHORT;
+	}
+	
+	if ( submesh->operationType == Ogre::RenderOperation::OT_TRIANGLE_LIST ){
+		numfaces = (int) index_data->indexCount / 3;
+		indexstride = (int) ibuf->getIndexSize()*3;
+	}
+	else
+		if ( submesh->operationType == Ogre::RenderOperation::OT_TRIANGLE_STRIP ){
+			numfaces = (int) index_data->indexCount -2;
+			indexstride = (int) ibuf->getIndexSize();
+		}
+		else{
+			ASSERT( 0 ); // not supported
+		}
+	
+	
+	
+	*indexbase = reinterpret_cast<unsigned char*>(ibuf->lock(Ogre::HardwareBuffer::HBL_READ_ONLY));
+}
+ 
+void MeshStrider::getLockedVertexIndexBase( unsigned char **vertexbase, int& numverts,PHY_ScalarType& type, int& stride,unsigned char **indexbase,int & indexstride,int& numfaces,PHY_ScalarType& indicestype,int subpart/*=0*/ )
+{
+    ASSERT( 0 );
+}
+ 
+void MeshStrider::unLockReadOnlyVertexBase( int subpart ) const
+{
+    Ogre::SubMesh* submesh = mMesh->getSubMesh(subpart);
+ 
+    Ogre::VertexData* vertex_data = submesh->useSharedVertices ? mMesh->sharedVertexData : submesh->vertexData;
+ 
+    const Ogre::VertexElement* posElem =
+        vertex_data->vertexDeclaration->findElementBySemantic(Ogre::VES_POSITION);
+ 
+    Ogre::HardwareVertexBufferSharedPtr vbuf =
+        vertex_data->vertexBufferBinding->getBuffer(posElem->getSource());
+ 
+    vbuf->unlock();
+ 
+    Ogre::IndexData* index_data = submesh->indexData;
+    Ogre::HardwareIndexBufferSharedPtr ibuf = index_data->indexBuffer;
+    ibuf->unlock();
+}
+ 
+void MeshStrider::unLockVertexBase( int subpart )
+{
+    ASSERT( 0 );
+}
+ 
+void MeshStrider::preallocateVertices( int numverts )
+{
+    ASSERT( 0 );
+}
+ 
+void MeshStrider::preallocateIndices( int numindices )
+{
+    ASSERT( 0 );
+}

data/ext/teienlib/src/MeshStrider.h

@@ -0,0 +1,48 @@
+#ifndef _MESHSTRIDER_H
+#define _MESHSTRIDER_H
+
+#include "Ogre.h"
+#include "btBulletCollisionCommon.h"
+#include "btBulletDynamicsCommon.h"
+
+#define ASSERT(a) 
+
+class MeshStrider : public btStridingMeshInterface
+{
+public:
+	MeshStrider( Ogre::Mesh * m = 0 ) : mMesh(m){}
+ 
+	void set( Ogre::Mesh * m ) { ASSERT(m); mMesh = m; }
+	// inherited interface
+	virtual int  getNumSubParts() const;
+ 
+	virtual void getLockedVertexIndexBase(unsigned char **vertexbase, 
+					      int& numverts,
+					      PHY_ScalarType& type, 
+					      int& stride,
+					      unsigned char **indexbase,
+					      int & indexstride,
+					      int& numfaces,
+					      PHY_ScalarType& indicestype,
+					      int subpart=0);
+	virtual void getLockedReadOnlyVertexIndexBase(const unsigned char **vertexbase, 
+						      int& numverts,
+						      PHY_ScalarType& type, 
+						      int& stride,
+						      const unsigned char **indexbase,
+						      int & indexstride,
+						      int& numfaces,
+						      PHY_ScalarType& indicestype,
+						      int subpart=0) const;
+ 
+    virtual void    unLockVertexBase(int subpart);
+    virtual void    unLockReadOnlyVertexBase(int subpart) const;
+ 
+    virtual void    preallocateVertices(int numverts);
+    virtual void    preallocateIndices(int numindices);
+
+private:
+    Ogre::Mesh * mMesh;
+};
+
+#endif

data/ext/teienlib/src/Shape.cc

@@ -0,0 +1,9 @@
+#include "Shape.h"
+
+namespace scl{
+
+Shape::Shape()
+{ 
+}
+
+}

data/ext/teienlib/src/Shape.h

@@ -0,0 +1,186 @@
+#ifndef SHAPE_H
+#define SHAPE_H
+
+#include "Vector3D.h"
+
+using namespace sul;
+
+namespace scl{
+
+struct Shape
+{
+	Shape();
+	virtual ~Shape(){}
+	virtual void setPos(Vector3D<float> aPos){ cerr << "Error: Shape::setPos()" << endl;}
+	
+	virtual const char* getClassName() const = 0;
+	
+	// aDir & localPos�ˤ����֤���ޤ�
+	//virtual void setPos(Vector3D<float> aPos, Vector3D<float> aDir){ cerr << "Error: Shape::setPos()" << endl;}
+	virtual void printInfo() const { cout << "struct: Shape" << endl; }
+	
+	/// relative position to Entity
+	/**
+	 * localPos�ϡ�Entity��pos(0, 0, 0), dir(0, -1, 0)�λ��ΰ��֤ˤ�������
+	 * dir�˴ؤ��Ƥϸ���̤�б�
+	 */
+	Vector3D<float> localPos;
+};
+
+struct AABB : public Shape
+{
+	AABB(){}
+	AABB(Vector3D<float> aMin, Vector3D<float> aMax) :	min(aMin), max(aMax){}
+	~AABB(){}
+	Vector3D<float> getCenter() const
+	{
+		return (min + max) / 2;
+	}
+	Vector3D<float> getRadius() const
+	{
+		return (max - min) / 2;
+	}
+	
+	void setPos(Vector3D<float> aCenter, Vector3D<float> aRad)
+	{
+		aCenter = aCenter + localPos;
+		min = aCenter - aRad;
+		max = aCenter + aRad;
+	}
+	void setPos(Vector3D<float> aCenter)
+	{
+		setPos(aCenter, getRadius());
+	}
+	void setRadius(Vector3D<float> aRad)
+	{
+		setPos(getCenter(), aRad);
+	}
+	
+	const char* getClassName() const { return "AABB"; }
+	
+	void printInfo() const 
+	{
+		Vector3D<float> vect = getCenter();
+		cout << "** struct: AABB [" << this << "]" << endl;
+		cout << "center: (" << vect.x << ", " << vect.y << ", " << vect.z <<")" << endl;
+		vect = getRadius();
+		cout << "radius: (" << vect.x << ", " << vect.y << ", " << vect.z <<")" << endl;
+	}
+	
+	Vector3D<float> min; 
+	Vector3D<float> max; 
+};
+
+struct Sphere : public Shape
+{
+	Sphere(){};
+	~Sphere(){};
+	Sphere(Vector3D<float> aCen, float aRad)
+	{
+		c = aCen + localPos; r = aRad;
+	}
+	
+	float getRadius() const { return r; }
+	Vector3D<float> getCenter() const { return c; }
+	
+	void setPos(Vector3D<float> aCenter)
+	{
+		c = aCenter + localPos;
+	}
+	void setRadius(float aRad)
+	{
+		r = aRad;
+	}
+	void setPos(Vector3D<float> aCenter, float aRad)
+	{
+		setPos(aCenter);
+		setRadius(aRad);
+	}
+	
+	const char* getClassName() const { return "Sphere"; }
+	
+	void printInfo() const 
+	{
+		Vector3D<float> vect = getCenter();
+		cout << "** struct: Sphere [" << this << "]" << endl;
+		cout << "center: (" << vect.x << ", " << vect.y << ", " << vect.z <<")" << endl;
+		cout << "radius: " << r << endl;
+	}
+	
+	Vector3D<float> c; // center
+	float			r;
+};
+
+/**
+ *	 n.dot(x) - d = 0;
+ *	 nx * x + ny * y + nz * z - d = 0;
+ */
+struct Plane : public Shape
+{
+	Plane(){};
+	Plane(Vector3D<float> aN, float aD) : n(aN), d(aD) {};
+	~Plane(){};
+	
+	const char* getClassName() const { return "Plane"; }
+	
+	void printInfo() const 
+	{
+		cout << "** struct: Plane [" << this << "]" << endl;
+		cout << "normal: (" << n.x << ", " << n.y << ", " << n.z <<")" << endl;
+		cout << "d: " << d << endl;
+	}
+	
+	Vector3D<float> n;	// d = n.dot(x) 
+	float			d;
+};
+
+
+/*
+ *
+ * �ʲ���collision�黻�Ѥˤ����Ȥ��Ƥ��ʤ�
+ *
+ */
+
+struct Segment : public Shape
+{
+	Segment(){};
+	Segment(Vector3D<float> aA, Vector3D<float> aB)
+	{
+		a = aA; b = aB;
+	}
+	~Segment(){};
+	
+	const char* getClassName() const { return "Segment"; }
+	
+	void printInfo() const 
+	{
+		cout << "** struct: Segment [" << this << "]" << endl;
+		cout << "a: (" << a.x << ", " << a.y << ", " << a.z <<")" << endl;
+		cout << "b: (" << b.x << ", " << b.y << ", " << b.z <<")" << endl;
+	}
+	
+	Vector3D<float> a;
+	Vector3D<float> b;
+};
+
+struct Capsule : public Shape
+{
+	Capsule(){};
+	~Capsule(){};
+	
+	const char* getClassName() const { return "Capsule"; }
+	
+	void printInfo() const 
+{
+		cout << "** struct: Capsule [" << this << "]" << endl;
+		cout << "segment: a(" << seg.a.x << ", " << seg.b.y << ", " << seg.b.z <<"), " 
+			 << "b(" << seg.b.x << ", " << seg.b.y << ", " << seg.b.z << ")" << endl;
+		cout << "radius: " << r << endl;
+	}
+	
+	Segment seg;
+	float	r;
+};
+
+}
+#endif

data/ext/teienlib/src/SimpleCollisionLibrary.h

@@ -0,0 +1,7 @@
+#ifndef SIMPLE_COLLISION_LIBRARY_H
+#define SIMPLE_COLLISION_LIBRARY_H
+
+#include "Collision.h"
+#include "Shape.h"
+
+#endif