NeHe OpenGL教程第三十课：碰撞检测

转自【翻译】NeHe OpenGL 教程

前言

声明，此 NeHe OpenGL教程系列文章由51博客yarin翻译（2010-08-19），本博客为转载并稍加整理与修改。对NeHe的OpenGL管线教程的编写，以及yarn的翻译整理表示感谢。

NeHe OpenGL第三十课：碰撞检测

碰撞检测:

这是一课激动的教程，你也许等待它多时了。你将学会碰撞剪裁，物理模拟太多的东西，慢慢期待吧。

碰撞检测和物理模拟(作者:Dimitrios Christopoulos (christop@fhw.gr))

碰撞检测

这是一个我遇到的最困难的题目,因为它没有一个简单的解决办法.对于每一个程序都有一种检测碰撞的方法.当然这里有一种蛮力,它适用于各种不同的应用,当它非常的费时.
我们将讲述一种算法,它非常的快,简单并易于扩展.下面我们来看看这个算法包含的内容:

1) 碰撞检测
移动的球-平面
移动的球-圆柱
移动的球-移动的球
2) 基于物理的建模
碰撞表示
应用重力加速度
3) 特殊效果
爆炸的表示，利用互交叉的公告板形式
声音使用Windows声音库
4) 关于代码
代码被分为以下5个部分
Lesson30.cpp : 主程序代码l
Image.cpp, Image.h : 加载图像
Tmatrix.cpp, Tmatrix.h : 矩阵
Tray.cpp, Tray.h : 射线
Tvector.cpp, Tvector.h : 向量

1) 碰撞检测

我们使用射线来完成相关的算法，它的定义为:

射线上的点 = 射线的原点+ t * 射线的方向

t 用来描述它距离原点的位置，它的范围是[0, 无限远).

现在我们可以使用射线来计算它和平面以及圆柱的交点了。

射线和平面的碰撞检测：

平面被描述为：

Xn dot X = d

Xn 是平面的法线.
X 是平面上的一个点.
d 是平面到原点的距离.

现在我们得到射线和平面的两个方程:

PointOnRay = Raystart + t * Raydirection
Xn dot X = d

如果他们相交，则上诉方程组有解，如下所示：

Xn dot PointOnRay = d

(Xn dot Raystart) + t * (Xn dot Raydirection) = d

解得 t:

t = (d - Xn dot Raystart) / (Xn dot Raydirection)

t代表原点到与平面相交点的参数,把t带回原方程我们会得到与平面的碰撞点.如果Xn*Raydirection=0。则说明它与平面平行，则将不产生碰撞。如果t为负值，则说明交点在射线的相反方向，也不会产生碰撞。

//判断是否和平面相交，是则返回1，否则返回0int TestIntersionPlane(const Plane& plane,const TVector& position,const TVector& direction, double& lamda, TVector&

pNormal){
double DotProduct=direction.dot(plane._Normal);
double l2;

//判断是否平行于平面
if ((DotProduct<ZERO)&&(DotProduct>-ZERO))
return 0;

l2=(plane._Normal.dot(plane._Position-position))/DotProduct;

if (l2<-ZERO)
return 0;

pNormal=plane._Normal;
lamda=l2;
return 1;
}

射线-圆柱的碰撞检测

计算射线和圆柱方程组得解。

int TestIntersionCylinder(const Cylinder& cylinder,const TVector& position,const TVector& direction, double& lamda, TVector& pNormal,TVector& newposition)

球-球之间的碰撞检测

球被表示为中心和它的半径，决定两个球是否相交就是求出它们之间的距离是否小于它们的直径。

在处理两个移动的球是否相交时，有一个bug就是，当它们的移动速度太快，回出现它们相交，但在相邻的两步检测不出它们是否相交的情况，如下图所示：

有一个替代的办法就是细分相邻的时间片断，如果在这之间发生了碰撞，则确定有效。我们把这个细分时间段设置为3，代码如下：

//判断球和球是否相交，是则返回1，否则返回0int FindBallCol(TVector& point, double& TimePoint, double Time2, int& BallNr1, int& BallNr2){ TVector RelativeV; TRay rays; double MyTime=0.0, Add=Time2/150.0, Timedummy=10000, Timedummy2=-1; TVector posi;  //判断球和球是否相交 for (int i=0;i<NrOfBalls-1;i++) { for (int j=i+1;j<NrOfBalls;j++) {       RelativeV=ArrayVel[i]-ArrayVel[j];   rays=TRay(OldPos[i],TVector::unit(RelativeV));   MyTime=0.0;
if ( (rays.dist(OldPos[j])) > 40) continue;

while (MyTime<Time2)
{
MyTime+=Add;
posi=OldPos[i]+RelativeV*MyTime;
if (posi.dist(OldPos[j])<=40) {
point=posi;
if (Timedummy>(MyTime-Add)) Timedummy=MyTime-Add;
BallNr1=i;
BallNr2=j;
break;
}

}
}

}

if (Timedummy!=10000) { TimePoint=Timedummy;
return 1;
}

return 0;
}

怎样应用我们的知识

现在我们已经可以决定射线和平面/圆柱的交点了,如下图所示:

当我们找到了碰撞位置后,下一步我们需要知道它是否发生在当前这一步中.如果距离碰撞点的位置小于这一步球体运动的间隔,则碰撞发生.我们使用如下的方程计算运动到碰撞时所需的时间:
Tc= Dsc*T / Dst
接着我们知道碰撞点位置,如下面公式所示:
Collision point= Start + Velocity*Tc

2) 基于物理的模拟

碰撞反应

为了计算对于一个静止物体的碰撞,我们需要知道以下信息:碰撞点,碰撞法线,碰撞时间.

它是基于以下物理规律的,碰撞的入射角等于反射角.如下图所示:

R 为反射方向
I 为入射方向
N 为法线方向

反射方向有以下公式计算 :

R= 2*(-I dot N)*N + I

rt2=ArrayVel[BallNr].mag();      // 返回速度向量的模
ArrayVel[BallNr].unit();      // 归一化速度向量

// 计算反射向量
ArrayVel[BallNr]=TVector::unit( (normal*(2*normal.dot(-ArrayVel[BallNr]))) + ArrayVel[BallNr] );
ArrayVel[BallNr]=ArrayVel[BallNr]*rt2;

球体之间的碰撞

由于它很复杂，我们用下图来说明这个原理.

U1和U2为速度向量，我们用X_Axis表示两个球中心连线的轴，U1X和U2X为U1和U2在这个轴上的分量。U1y和U2y为垂直于X_Axis轴的分量。M1和M2为两个球体的分量。V1和V2为碰撞后的速度，V1x,V1y,V2x,V2y为他们的分量。

在我们的例子里，所有球的质量都相等，解得方程为，在垂直轴上的速度不变，在X_Axis轴上互相交换速度。代码如下：

TVector pb1,pb2,xaxis,U1x,U1y,U2x,U2y,V1x,V1y,V2x,V2y;
double a,b;
pb1=OldPos[BallColNr1]+ArrayVel[BallColNr1]*BallTime;   // 球1的位置
pb2=OldPos[BallColNr2]+ArrayVel[BallColNr2]*BallTime;   // 球2的位置
xaxis=(pb2-pb1).unit();       // X-Axis轴
a=xaxis.dot(ArrayVel[BallColNr1]);     // X_Axis投影系数
U1x=xaxis*a;        // 计算在X_Axis轴上的速度
U1y=ArrayVel[BallColNr1]-U1x; // 计算在垂直轴上的速度
xaxis=(pb1-pb2).unit();
b=xaxis.dot(ArrayVel[BallColNr2]);
U2x=xaxis*b;
U2y=ArrayVel[BallColNr2]-U2x;
V1x=(U1x+U2x-(U1x-U2x))*0.5;      // 计算新的速度
V2x=(U1x+U2x-(U2x-U1x))*0.5;
V1y=U1y;
V2y=U2y;
for (j=0;j<NrOfBalls;j++)      // 更新所有球的位置
ArrayPos[j]=OldPos[j]+ArrayVel[j]*BallTime;
ArrayVel[BallColNr1]=V1x+V1y;      // 设置新的速度
ArrayVel[BallColNr2]=V2x+V2y;

万有引力的模拟

我们使用欧拉方程来模拟万有引力，如下所示：
Velocity_New = Velovity_Old + Acceleration*TimeStep
Position_New = Position_Old + Velocity_New*TimeStep

在每次模拟中，我们用上面公式计算的速度取代旧的速度

3) 特殊效果

爆炸

最好的表示爆炸效果的就是使用两个互相垂直的平面，并使用alpha混合在窗口中显示它们。接着让alpha变为0，设定爆炸效果不可见。代码如下所示：

// 渲染/混合爆炸效果
glEnable(GL_BLEND);       // 使用混合
glDepthMask(GL_FALSE);       // 禁用深度缓存
glBindTexture(GL_TEXTURE_2D, texture[1]);    // 设置纹理
for(i=0; i<20; i++)       // 渲染20个爆炸效果
{
if(ExplosionArray[i]._Alpha>=0)
{
  glPushMatrix();
  ExplosionArray[i]._Alpha-=0.01f;   // 设置alpha
  ExplosionArray[i]._Scale+=0.03f;   // 设置缩放
  // 设置颜色
  glColor4f(1,1,0,ExplosionArray[i]._Alpha);
  glScalef(ExplosionArray[i]._Scale,ExplosionArray[i]._Scale,ExplosionArray[i]._Scale);
  // 设置位置
  glTranslatef((float)ExplosionArray[i]._Position.X()/ExplosionArray[i]._Scale,
   (float)ExplosionArray[i]._Position.Y()/ExplosionArray[i]._Scale,
   (float)ExplosionArray[i]._Position.Z()/ExplosionArray[i]._Scale);
  glCallList(dlist);     // 调用显示列表绘制爆炸效果
  glPopMatrix();
}
}

声音

在Windows下我们简单的调用PlaySound()函数播放声音。

4) 代码的流程

如果你成功的读完了理论部分，在你开始运行程序并播放声音以前。我们将用伪代码向你介绍一些整个流程，以便你能成功的看懂代码。

While (Timestep!=0)
{
对每一个球
{
  计算最近的与平面碰撞的位置;
  计算最近的与圆柱碰撞的位置;
  如果碰撞发生，则保存并替换最近的碰撞点;
}
检测各个球之间的碰撞;
如果碰撞发生，则保存并替换最近的碰撞点;

If (碰撞发生)
{
  移动所有的球道碰撞点的时间;
  (We already have computed the point, normal and collision time.)
  计算碰撞后的效果;
  Timestep-=CollisonTime;
}
else
  移动所有的球体一步
}

下面是对上面伪代码的实现：

//模拟函数，计算碰撞检测和物理模拟void idle(){ double rt,rt2,rt4,lamda=10000; TVector norm,uveloc; TVector normal,point,time; double RestTime,BallTime; TVector Pos2; int BallNr=0,dummy=0,BallColNr1,BallColNr2; TVector Nc;
//如果没有锁定到球上，旋转摄像机
if (!hook_toball1)
{
camera_rotation+=0.1f;
if (camera_rotation>360)
camera_rotation=0;
}

RestTime=Time;
lamda=1000;

//计算重力加速度
for (int j=0;j<NrOfBalls;j++)
ArrayVel[j]+=accel*RestTime;

//如果在一步的模拟时间内(如果来不及计算，则跳过几步)
while (RestTime>ZERO)
{
lamda=10000;

//对于每个球，找到它们最近的碰撞点
for (int i=0;i<NrOfBalls;i++)
{
//计算新的位置和移动的距离
OldPos[i]=ArrayPos[i];
TVector::unit(ArrayVel[i],uveloc);
ArrayPos[i]=ArrayPos[i]+ArrayVel[i]*RestTime;
rt2=OldPos[i].dist(ArrayPos[i]);

//测试是否和墙面碰撞
if (TestIntersionPlane(pl1,OldPos[i],uveloc,rt,norm))
{
//计算碰撞的时间
rt4=rt*RestTime/rt2;

//如果小于当前保存的碰撞时间，则更新它
if (rt4<=lamda)
{
if (rt4<=RestTime+ZERO)
if (! ((rt<=ZERO)&&(uveloc.dot(norm)>ZERO)) )
{
normal=norm;
point=OldPos[i]+uveloc*rt;
lamda=rt4;
BallNr=i;
}
}
}

if (TestIntersionPlane(pl2,OldPos[i],uveloc,rt,norm))
{
rt4=rt*RestTime/rt2;

if (rt4<=lamda)
{
if (rt4<=RestTime+ZERO)
if (! ((rt<=ZERO)&&(uveloc.dot(norm)>ZERO)) )
{
normal=norm;
point=OldPos[i]+uveloc*rt;
lamda=rt4;
BallNr=i;
dummy=1;
}
}

}

if (TestIntersionPlane(pl3,OldPos[i],uveloc,rt,norm))
{
rt4=rt*RestTime/rt2;

if (rt4<=lamda)
{
if (rt4<=RestTime+ZERO)
if (! ((rt<=ZERO)&&(uveloc.dot(norm)>ZERO)) )
{
normal=norm;
point=OldPos[i]+uveloc*rt;
lamda=rt4;
BallNr=i;
}
}
}

if (TestIntersionPlane(pl4,OldPos[i],uveloc,rt,norm))
{
rt4=rt*RestTime/rt2;

if (rt4<=lamda)
{
if (rt4<=RestTime+ZERO)
if (! ((rt<=ZERO)&&(uveloc.dot(norm)>ZERO)) )
{
normal=norm;
point=OldPos[i]+uveloc*rt;
lamda=rt4;
BallNr=i;
}
}
}

if (TestIntersionPlane(pl5,OldPos[i],uveloc,rt,norm))
{
rt4=rt*RestTime/rt2;

if (rt4<=lamda)
{
if (rt4<=RestTime+ZERO)
if (! ((rt<=ZERO)&&(uveloc.dot(norm)>ZERO)) )
{
normal=norm;
point=OldPos[i]+uveloc*rt;
lamda=rt4;
BallNr=i;
}
}
}

//测试是否与三个圆柱相碰
if (TestIntersionCylinder(cyl1,OldPos[i],uveloc,rt,norm,Nc))
{
rt4=rt*RestTime/rt2;

if (rt4<=lamda)
{
if (rt4<=RestTime+ZERO)
if (! ((rt<=ZERO)&&(uveloc.dot(norm)>ZERO)) )
{
normal=norm;
point=Nc;
lamda=rt4;
BallNr=i;
}
}

}
if (TestIntersionCylinder(cyl2,OldPos[i],uveloc,rt,norm,Nc))
{
rt4=rt*RestTime/rt2;

if (rt4<=lamda)
{
if (rt4<=RestTime+ZERO)
if (! ((rt<=ZERO)&&(uveloc.dot(norm)>ZERO)) )
{
normal=norm;
point=Nc;
lamda=rt4;
BallNr=i;
}
}

}
if (TestIntersionCylinder(cyl3,OldPos[i],uveloc,rt,norm,Nc))
{
rt4=rt*RestTime/rt2;

if (rt4<=lamda)
{
if (rt4<=RestTime+ZERO)
if (! ((rt<=ZERO)&&(uveloc.dot(norm)>ZERO)) )
{
normal=norm;
point=Nc;
lamda=rt4;
BallNr=i;
}
}

}
}

//计算每个球之间的碰撞，如果碰撞时间小于与上面的碰撞，则替换它们
if (FindBallCol(Pos2,BallTime,RestTime,BallColNr1,BallColNr2))
{
if (sounds)
PlaySound("Data/Explode.wav",NULL,SND_FILENAME|SND_ASYNC);

if ( (lamda==10000) || (lamda>BallTime) )
{
RestTime=RestTime-BallTime;

TVector pb1,pb2,xaxis,U1x,U1y,U2x,U2y,V1x,V1y,V2x,V2y;
double a,b;

pb1=OldPos[BallColNr1]+ArrayVel[BallColNr1]*BallTime;
pb2=OldPos[BallColNr2]+ArrayVel[BallColNr2]*BallTime;
xaxis=(pb2-pb1).unit();

a=xaxis.dot(ArrayVel[BallColNr1]);
U1x=xaxis*a;
U1y=ArrayVel[BallColNr1]-U1x;

xaxis=(pb1-pb2).unit();
b=xaxis.dot(ArrayVel[BallColNr2]);
U2x=xaxis*b;
U2y=ArrayVel[BallColNr2]-U2x;

V1x=(U1x+U2x-(U1x-U2x))*0.5;
V2x=(U1x+U2x-(U2x-U1x))*0.5;
V1y=U1y;
V2y=U2y;

for (j=0;j<NrOfBalls;j++)
ArrayPos[j]=OldPos[j]+ArrayVel[j]*BallTime;

ArrayVel[BallColNr1]=V1x+V1y;
ArrayVel[BallColNr2]=V2x+V2y;

//Update explosion array
for(j=0;j<20;j++)
{
if (ExplosionArray[j]._Alpha<=0)
{
ExplosionArray[j]._Alpha=1;
ExplosionArray[j]._Position=ArrayPos[BallColNr1];
ExplosionArray[j]._Scale=1;
break;
}
}

continue;
}
}

//最后的测试，替换下次碰撞的时间，并更新爆炸效果的数组
if (lamda!=10000)
{
RestTime-=lamda;

for (j=0;j<NrOfBalls;j++)
ArrayPos[j]=OldPos[j]+ArrayVel[j]*lamda;

rt2=ArrayVel[BallNr].mag();
ArrayVel[BallNr].unit();
ArrayVel[BallNr]=TVector::unit( (normal*(2*normal.dot(-ArrayVel[BallNr]))) + ArrayVel[BallNr] );
ArrayVel[BallNr]=ArrayVel[BallNr]*rt2;

for(j=0;j<20;j++)
{
  if (ExplosionArray[j]._Alpha<=0)
  {
   ExplosionArray[j]._Alpha=1;
   ExplosionArray[j]._Position=point;
   ExplosionArray[j]._Scale=1;
   break;
  }
}
}
else
RestTime=0;
}
}
原文及其个版本源代码下载：