Box2d源码学习<九>形状(中)：边缘形状和链形状的实现

本系列博客是由扭曲45原创，欢迎转载，转载时注明出处，http://blog.csdn.net/cg0206/article/details/8302347

Box2d 2.2.1中父形状shape将有4个子形状，分别是b2EdgeShape(边缘形状)、b2ChainShape(链形状)、b2Circle(圆形状)和b2PolygonShape(多边形形状)。我们今天就来先看看边缘形状和链形状。

1、 边缘形状，边缘形状是由多条线段组成。不能与自己进行碰撞检测，只能与圆和多边形进行碰撞检测。在box2d中，如果要想检测两个形状是否碰撞，形状必须要有体积的，故边缘形状不能和边缘形状碰撞。我们就来看看b2EdgeShape的定义吧，打开b2EdgeShape.h文件。

 //  一个线段(边缘)形状。这些可以连接在链或者环其他边缘形状。
//连接信息是用来确保正确的联系法线
class b2EdgeShape : public b2Shape
{
public:
	/**************************************************************************
	* 功能描述： 构造函数
	* 参数说明： (void)
	* 返 回 值： (void)
	***************************************************************************/
	b2EdgeShape();
	/**************************************************************************
	* 功能描述： 设置独立的边缘
	* 参数说明： v1 : 第一个顶点
	             v2 : 第二个顶点
	* 返 回 值： (void)
	***************************************************************************/
	void Set(const b2Vec2& v1, const b2Vec2& v2);
	/**************************************************************************
	* 功能描述：用soa块分配器克隆一个具体的形状
	* 参数说明： allocator ：soa分配器对象指针
	* 返 回 值： 形状指针
	***************************************************************************/
	b2Shape* Clone(b2BlockAllocator* allocator) const;
	/**************************************************************************
	* 功能描述：获取形状的孩子元素的数量
	* 参数说明： (void)
	* 返 回 值： 孩子元素的数量
	***************************************************************************/
	int32 GetChildCount() const;
	/**************************************************************************
	* 功能描述：在这个形状中测试这个点的密封性，只适合用于凸的形状
	* 参数说明： xf : 形状的变换
	             p  : world坐标中的一个点
	* 返 回 值： true : 密封
	             false：敞开
	***************************************************************************/
	bool TestPoint(const b2Transform& transform, const b2Vec2& p) const;
	/**************************************************************************
	* 功能描述：投射一束光到一个孩子形状中
	* 参数说明： output      ：输出光线投射的结果
	             input       ：输入光线投射
				 transform   ：变换应用到此形状中
				 childeIndex ：孩子形状索引
	* 返 回 值： true : 成功
	             false：失败
	***************************************************************************/
	bool RayCast(b2RayCastOutput* output, const b2RayCastInput& input,
				const b2Transform& transform, int32 childIndex) const;
	/**************************************************************************
	* 功能描述：给出一个变换，计算一个孩子形状的轴对齐包围盒(aabb)
	* 参数说明： aabb       : 孩子形状的aabb指针
	             xf         : 一个变换的引用
				 childIndex : 孩子的索引值
	* 返 回 值： (void)
	***************************************************************************/
	void ComputeAABB(b2AABB* aabb, const b2Transform& transform, int32 childIndex) const;
	/**************************************************************************
	* 功能描述：用它的大小和密度计算形状的质量
	* 参数说明： massData   : 计算形状的质量
	             density    : 密度
	* 返 回 值： (void)
	***************************************************************************/
	void ComputeMass(b2MassData* massData, float32 density) const;
	//  边缘形状的顶点
	b2Vec2 m_vertex1, m_vertex2;
	// 可选的相邻的顶点，它们用于平滑碰撞
	b2Vec2 m_vertex0, m_vertex3;
	//是否含有相邻顶点
	bool m_hasVertex0, m_hasVertex3;
};
//构造函数，用于初始化
inline b2EdgeShape::b2EdgeShape()
{
	m_type = e_edge;
	m_radius = b2_polygonRadius;
	m_vertex0.x = 0.0f;
	m_vertex0.y = 0.0f;
	m_vertex3.x = 0.0f;
	m_vertex3.y = 0.0f;
	m_hasVertex0 = false;
	m_hasVertex3 = false;
}

我们可以看到b2EdgeShape继承了b2Shape类，并对虚方法进行了重新定义。同时我们也实现了一个内联构造函数，进行对b2EdgeShape类进行初始化的时候使用。这方面，也不多说了，再来看看它的实现。

//设置独立的边缘
void b2EdgeShape::Set(const b2Vec2& v1, const b2Vec2& v2)
{
	m_vertex1 = v1;
	m_vertex2 = v2;
	m_hasVertex0 = false;
	m_hasVertex3 = false;
}

//用soa块分配器克隆一个具体的形状
b2Shape* b2EdgeShape::Clone(b2BlockAllocator* allocator) const
{
	//在内存池中申请一块内存
	void* mem = allocator->Allocate(sizeof(b2EdgeShape));
	//在一块已存在的内存上分配对象
	b2EdgeShape* clone = new (mem) b2EdgeShape;
	*clone = *this;
	return clone;
}
//获取形状的孩子元素的数量
int32 b2EdgeShape::GetChildCount() const
{
	return 1;
}
//在这个形状中测试这个点的密封性，只适合用于凸的形状
bool b2EdgeShape::TestPoint(const b2Transform& xf, const b2Vec2& p) const
{
	// 消除编译器产生的警告
	B2_NOT_USED(xf);
	B2_NOT_USED(p);
	return false;
}
//光线投射
// p = p1 + t * d
// v = v1 + s * e
// p1 + t * d = v1 + s * e
// s * e - t * d = p1 - v1
bool b2EdgeShape::RayCast(b2RayCastOutput* output, const b2RayCastInput& input,
							const b2Transform& xf, int32 childIndex) const
{
	//消除编译器
	B2_NOT_USED(childIndex);
	//把光线投入到边缘框架的参考系中
	//下面是根据给定的公式在计算，
	//光线投射最近也在研究中，就不误导大家啦。。。
	b2Vec2 p1 = b2MulT(xf.q, input.p1 - xf.p);
	b2Vec2 p2 = b2MulT(xf.q, input.p2 - xf.p);
	b2Vec2 d = p2 - p1;

	b2Vec2 v1 = m_vertex1;
	b2Vec2 v2 = m_vertex2;
	b2Vec2 e = v2 - v1;
	b2Vec2 normal(e.y, -e.x);
	normal.Normalize();

	// q = p1 + t * d
	// dot(normal, q - v1) = 0
	// dot(normal, p1 - v1) + t * dot(normal, d) = 0
	float32 numerator = b2Dot(normal, v1 - p1);
	float32 denominator = b2Dot(normal, d);

	if (denominator == 0.0f)
	{
		return false;
	}

	float32 t = numerator / denominator;
	if (t < 0.0f || input.maxFraction < t)
	{
		return false;
	}

	b2Vec2 q = p1 + t * d;

	// q = v1 + s * r
	// s = dot(q - v1, r) / dot(r, r)
	b2Vec2 r = v2 - v1;
	float32 rr = b2Dot(r, r);
	if (rr == 0.0f)
	{
		return false;
	}

	float32 s = b2Dot(q - v1, r) / rr;
	if (s < 0.0f || 1.0f < s)
	{
		return false;
	}

	output->fraction = t;
	if (numerator > 0.0f)
	{
		output->normal = -normal;
	}
	else
	{
		output->normal = normal;
	}
	return true;
}
//给出一个变换，计算一个孩子形状的轴对齐包围盒(aabb)
void b2EdgeShape::ComputeAABB(b2AABB* aabb, const b2Transform& xf, int32 childIndex) const
{
	//消除编译器产生的警告
	B2_NOT_USED(childIndex);

	b2Vec2 v1 = b2Mul(xf, m_vertex1);
	b2Vec2 v2 = b2Mul(xf, m_vertex2);

	b2Vec2 lower = b2Min(v1, v2);
	b2Vec2 upper = b2Max(v1, v2);
	//重新设置aabb
	b2Vec2 r(m_radius, m_radius);
	aabb->lowerBound = lower - r;
	aabb->upperBound = upper + r;
}
//计算质量
void b2EdgeShape::ComputeMass(b2MassData* massData, float32 density) const
{
	//消除编译器产生的警告
	B2_NOT_USED(density);
	//设置用户数据
	massData->mass = 0.0f;
	massData->center = 0.5f * (m_vertex1 + m_vertex2);
	massData->I = 0.0f;
}

关于b2EdgeShape的实现，我们先来看下Clone函数，用SOA(小型对象分配器)分配了一块内存后，我们又用new在一块已存在的内存上分配对象，这是new的另外一种用法placement new，如果有童鞋对此不太理解或者想更深入研究的话，可以参照以下链接http://blog.sina.com.cn/s/blog_69e905cd0100k51b.html或http://club.topsage.com/thread-2467284-1-1.html，还有就是RayCast函数，主要就是根据注释上面的公式求解，然后就能获得结果。如果还有童鞋进一步了解的话，可以看《CollisionDetection inInteractive 3D Environments》这本书。当然我们通过上面代码可以简单的看到，b2EdgeShape是重量为零、密封性为假的形状。

 

2、 链形状，链形状是一个自由形式的序列的线段，链具有双面碰撞，故你可以使用内部或者外部碰撞。链形状提供了一种高效的方法来同时连接多条边，为你的游戏创造静态的游戏世界。链形状同时提供了创建链和环的方法，以便为大家提供想要的形状。链形状不能自身交叉，那样它有可能不能正常的工作。在Box2d中，链形状是通过b2ChainShape实现的。我们就来看看它是怎么做到的。

首先，我们看b2ChainShape.h文件。

//声明
class b2EdgeShape;

// 链形状是一个自由形式的序列的线段，链具有双面碰撞，故你可以使用内部和外部碰撞
// 同时，你可以使用任何缠绕的顺序。尽管可能有很多顶点，不过它们都是通过b2Alloc分配的。
// 链接信息是用来创建平滑的碰撞
// 警告：如果他们自身交叉时，有可能不会正确的处理碰撞
//       即有可能正常工作，也有可能不正常工作
class b2ChainShape : public b2Shape
{
public:
	/**************************************************************************
	* 功能描述： 链形状构造函数
	* 参数说明： (void)
	* 返 回 值： (void)
	***************************************************************************/
	b2ChainShape();
	/**************************************************************************
	* 功能描述： 析构函数，用b2Free释放多个点
	* 参数说明： (void)
	* 返 回 值： (void)
	***************************************************************************/
	~b2ChainShape();
	/**************************************************************************
	* 功能描述： 创建一个环。自动调整连接
	* 参数说明： vertices : 顶点数组，拷贝它们
	             count    : 顶点的数量
	* 返 回 值： (void)
	***************************************************************************/
	void CreateLoop(const b2Vec2* vertices, int32 count);
	/**************************************************************************
	* 功能描述： 用孤立的点创建一个链
	* 参数说明： vertices : 顶点数组，拷贝它们
	             count    : 顶点的数量
	* 返 回 值： (void)
	***************************************************************************/
	void CreateChain(const b2Vec2* vertices, int32 count);
	/**************************************************************************
	* 功能描述： 创建由一个顶点连接到上个顶点的链接
	             不要在环中调用【即不能调用CreateLoop创建了环之后在调用此函数】
	* 参数说明： prevVertex : 上一个顶点
	* 返 回 值： (void)
	***************************************************************************/
	void SetPrevVertex(const b2Vec2& prevVertex);
	/**************************************************************************
	* 功能描述： 创建由一个顶点连接到下个顶点的链接
	             不要在环中调用【即不能调用CreateLoop创建了环之后在调用此函数】
	* 参数说明： vertices : 下一个顶点
	* 返 回 值： (void)
	***************************************************************************/
	void SetNextVertex(const b2Vec2& nextVertex);
	/**************************************************************************
	* 功能描述： 用b2Alloc克隆所有顶点
	             不要在环中调用【即不能调用CreateLoop创建了环之后在调用此函数】
	* 参数说明： allocator : soa对象指针
	* 返 回 值： 形状对象指针
	***************************************************************************/
	b2Shape* Clone(b2BlockAllocator* allocator) const;
	/**************************************************************************
	* 功能描述：获取形状的孩子元素的数量
	* 参数说明： (void)
	* 返 回 值： 形状类型
	***************************************************************************/
	int32 GetChildCount() const;

	/**************************************************************************
	* 功能描述：根据索引值从链中获取指定的边缘形状
	* 参数说明： edge :b2EdgeShape对象指针
	             index:索引值
	* 返 回 值： (void)
	***************************************************************************/
	void GetChildEdge(b2EdgeShape* edge, int32 index) const;
	/**************************************************************************
	* 功能描述：在这个形状中测试这个点的密封性，只适合用于凸的形状
	* 参数说明： xf : 形状的变换
	             p  : world坐标中的一个点
	* 返 回 值： true : 密封
	             false：敞开
				 总是返回false
	***************************************************************************/
	bool TestPoint(const b2Transform& transform, const b2Vec2& p) const;
	/**************************************************************************
	* 功能描述：投射一束光到一个链形状中
	* 参数说明： output      ：输出光线投射的结果
	             input       ：输入光线投射
				 transform   ：变换应用到此形状中
				 childeIndex ：孩子形状索引
	* 返 回 值： true : 成功
	             false：失败
	***************************************************************************/
	bool RayCast(b2RayCastOutput* output, const b2RayCastInput& input,
					const b2Transform& transform, int32 childIndex) const;
	/**************************************************************************
	* 功能描述：给出一个变换，计算一个孩子形状的轴对齐包围盒(aabb)
	            不要在环中调用【即不能调用CreateLoop创建了环之后在调用此函数】
	* 参数说明： aabb       : 孩子形状的aabb指针
	             xf         : 一个变换的引用
				 childIndex : 孩子的索引值
	* 返 回 值： (void)
	***************************************************************************/
	void ComputeAABB(b2AABB* aabb, const b2Transform& transform, int32 childIndex) const;
	/**************************************************************************
	* 功能描述：用它的大小和密度计算形状的质量
	            Chains的质量为0
				不要在环中调用【即不能调用CreateLoop创建了环之后在调用此函数】
	* 参数说明： massData   : 计算形状的质量
	             density    : 密度
	* 返 回 值： (void)
	***************************************************************************/
	void ComputeMass(b2MassData* massData, float32 density) const;
	// 顶点数组
	b2Vec2* m_vertices;

	//顶点个数
	int32 m_count;
	//前顶点，后顶点
	b2Vec2 m_prevVertex, m_nextVertex;
	//是否拥有前顶点，后顶点
	bool m_hasPrevVertex, m_hasNextVertex;
};
//构造函数
inline b2ChainShape::b2ChainShape()
{
	m_type = e_chain;
	m_radius = b2_polygonRadius;
	m_vertices = NULL;
	m_count = 0;
	m_hasPrevVertex = NULL;
	m_hasNextVertex = NULL;
}

我们可以看到开始的时候，将b2EdgeShape类声明了一下，作为一个标签放入头文件中，在链接的时候，链接器会做相应的处理。【这里我们知道一下就行，不必深究】。当然，b2ChainShape类也继承了b2Shape类，并对父类的虚方法进行了重新定义和实现【当然是ccp文件啦】。构造函数同样也是初始化相关信息。

//析构函数
b2ChainShape::~b2ChainShape()
{
	b2Free(m_vertices);
	m_vertices = NULL;
	m_count = 0;
}
//创建一个循环。自动调整连接
void b2ChainShape::CreateLoop(const b2Vec2* vertices, int32 count)
{
	//验证是否没有顶点
	b2Assert(m_vertices == NULL && m_count == 0);
	//验证顶点的个数
	b2Assert(count >= 3);
	//在顶点个数基础上加1，
	//用于将第一个元素放到最后一个空间中，
	//这样就会形成一个环状,方便操作
	m_count = count + 1;
	//申请一个顶点动态数组，并拷贝旧数组中的数据到新空间中
	m_vertices = (b2Vec2*)b2Alloc(m_count * sizeof(b2Vec2));
	memcpy(m_vertices, vertices, count * sizeof(b2Vec2));
	//申请一个
	m_vertices[count] = m_vertices[0];
	//前一个顶点、后一个顶点
	m_prevVertex = m_vertices[m_count - 2];
	m_nextVertex = m_vertices[1];
	m_hasPrevVertex = true;
	m_hasNextVertex = true;
}
//用孤立的点创建一个链
void b2ChainShape::CreateChain(const b2Vec2* vertices, int32 count)
{
	//没有顶点
	b2Assert(m_vertices == NULL && m_count == 0);
	//顶点数要过大
	b2Assert(count >= 2);
	// 
	m_count = count;
	//申请一个顶点动态数组，并拷贝旧数组中的数据到新空间中
	m_vertices = (b2Vec2*)b2Alloc(count * sizeof(b2Vec2));
	memcpy(m_vertices, vertices, m_count * sizeof(b2Vec2));
	//没有左右节点
	m_hasPrevVertex = false;
	m_hasNextVertex = false;
}
//创建由一个顶点连接到上个顶点的链接
void b2ChainShape::SetPrevVertex(const b2Vec2& prevVertex)
{
	m_prevVertex = prevVertex;
	m_hasPrevVertex = true;
}
//创建由一个顶点连接到下个顶点的链接
void b2ChainShape::SetNextVertex(const b2Vec2& nextVertex)
{
	m_nextVertex = nextVertex;
	m_hasNextVertex = true;
}
//用b2Alloc克隆所有顶点
b2Shape* b2ChainShape::Clone(b2BlockAllocator* allocator) const
{
	//申请一块内存
	void* mem = allocator->Allocate(sizeof(b2ChainShape));
	//在一块已存在的内存上分配对象
	b2ChainShape* clone = new (mem) b2ChainShape;
	//创建链
	clone->CreateChain(m_vertices, m_count);
	//获取相关信息，并返回
	clone->m_prevVertex = m_prevVertex;
	clone->m_nextVertex = m_nextVertex;
	clone->m_hasPrevVertex = m_hasPrevVertex;
	clone->m_hasNextVertex = m_hasNextVertex;
	return clone;
}
//获取形状的孩子元素的数量
int32 b2ChainShape::GetChildCount() const
{
	// edge count = vertex count - 1
	return m_count - 1;
}
//根据索引值从链中获取指定的边缘形状
void b2ChainShape::GetChildEdge(b2EdgeShape* edge, int32 index) const
{
	//验证索引值
	b2Assert(0 <= index && index < m_count - 1);
	//复制类型，半径
	edge->m_type = b2Shape::e_edge;
	edge->m_radius = m_radius;
	//获取两端坐标
	edge->m_vertex1 = m_vertices[index + 0];
	edge->m_vertex2 = m_vertices[index + 1];

	//根据CreateLoop中可以知道，第一个元素和最后一个元素是一样的
	//所以要单独判断
	//判断索引值是否是第一个元素
	if (index > 0)
	{
		edge->m_vertex0 = m_vertices[index - 1];
		edge->m_hasVertex0 = true;
	}
	else
	{
		edge->m_vertex0 = m_prevVertex;
		edge->m_hasVertex0 = m_hasPrevVertex;
	}
	//判断索引值是否是最后一个元素
	if (index < m_count - 2)
	{
		edge->m_vertex3 = m_vertices[index + 2];
		edge->m_hasVertex3 = true;
	}
	else
	{
		edge->m_vertex3 = m_nextVertex;
		edge->m_hasVertex3 = m_hasNextVertex;
	}
}
//在这个形状中测试这个点的密封性，只适合用于凸的形状
bool b2ChainShape::TestPoint(const b2Transform& xf, const b2Vec2& p) const
{
	B2_NOT_USED(xf);
	B2_NOT_USED(p);
	return false;
}
//投射一束光到一个链形状中
bool b2ChainShape::RayCast(b2RayCastOutput* output, const b2RayCastInput& input,
							const b2Transform& xf, int32 childIndex) const
{
	//验证孩子形状索引有效性
	b2Assert(childIndex < m_count);

	b2EdgeShape edgeShape;

	int32 i1 = childIndex;
	int32 i2 = childIndex + 1;
	//最后一个元素，单独判断
	if (i2 == m_count)
	{
		i2 = 0;
	}
	//初始化edgeShape
	edgeShape.m_vertex1 = m_vertices[i1];
	edgeShape.m_vertex2 = m_vertices[i2];

	return edgeShape.RayCast(output, input, xf, 0);
}
//计算顶点的上下边界
void b2ChainShape::ComputeAABB(b2AABB* aabb, const b2Transform& xf, int32 childIndex) const
{
	//验证孩子形状索引有效性
	b2Assert(childIndex < m_count);
	//获取坐标
	int32 i1 = childIndex;
	int32 i2 = childIndex + 1;
	//最一个元素，单独判断
	if (i2 == m_count)
	{
		i2 = 0;
	}
	//获取aabb的上下边界
	b2Vec2 v1 = b2Mul(xf, m_vertices[i1]);
	b2Vec2 v2 = b2Mul(xf, m_vertices[i2]);

	aabb->lowerBound = b2Min(v1, v2);
	aabb->upperBound = b2Max(v1, v2);
}
//计算质量
void b2ChainShape::ComputeMass(b2MassData* massData, float32 density) const
{
	//消除编译器警告
	B2_NOT_USED(density);
	//置空成员变量
	massData->mass = 0.0f;
	massData->center.SetZero();
	massData->I = 0.0f;
}

主要来看CreateLoop函数和CreateChain函数，它们的差别是很细微的，但是细微的差别带来的却是本质的变化，在CreateLoop函数中，我们申请了count+1顶点，比我们设置的要多出来一个顶点，这是干什么呢？主要是利用多申请的那个点的空间，放第一个顶点的信息，同时设置这两个点的前后顶点，并设置m_hasPrevVertex = true,和m_hasNextVertex = true，这样就形成了一个环了。而CreateChain函数则是直接申请了Count个顶点，并设置没有前后点。同时b2ChainShape也是零质量、密封性为假的形状。每两个点形成的形状就是边缘形状，我们可以通过GetChildEdge进行获取。其他的和前面的差不多，就不多说了。下一篇我们继续看剩下的两个形状。

 

ps：

 

以上文章仅是一家之言，若有不妥、错误之处，请大家多多指出。同时也希望能与大家多多交流，共同进步。