游戏物理中的碰撞测试（一） - 如何检测碰撞

日期：2008年10月

介绍

在文章中我会介绍3D撞击测试的原理和一些基本的实现步骤，当然也会写一些我在实现上的心得。所有的例子我都是在Visual C++ Express 2008里编译，还需要下载最新版本的OpenGL类库。我想提一下，这并不是一个新的课题，文章的主要目的是使你了解物理碰撞中的数学理论和分析方式，至于编程语言我认为你并不一定使用C++，可以完全可以使用C#或者是你其他喜欢的语言（只要你清楚实现步骤）。源文件一般都附带在文章中，以便于学习讨论，你完全可以下载使用我写的类，但是请务必注明出处。

碰撞测试

当做研究或者学习时，通常在理想的环境进行。碰撞牵扯到两个或者多个物体，物体大小不一，规则形状不同。在这里我从最简单最基本的写起，拿一个球体和一个平面的撞击举例（这也是我能想到最简单的最容易让读者看懂的例子）。顺便说一下，这里我所说的球体都是想象出来的（有着半径R，体积为4/3乘PI乘R平方），现实世界中不存在真正的球体，电脑里也不存在真正的球体。

现实中你在空地上抛出一个小球，那么小球会落到地面上并且反弹一下，或者当你对着墙壁抛出一个小球，那么小球也会弹回。那么小球撞击地面，墙面的过程就是要讨论的碰撞。发挥你的想象，把墙壁想象成一个3D空间的平面。从逻辑角度来说，小球向墙壁方向移动时，当小球碰到墙壁的时候，那么就知道小球撞倒墙壁了。那么怎么让程序知道小球撞击到墙壁了呢？

建议

如果你在空间中想象一个小球碰撞平面有困难的话，那么你可以尝试把小球想象成一个点，这个点就是小球的球心。



Hum！想象一个场景，一个沿着直线向右匀速运动的小球去撞击一堵墙。可能你会觉得用3D空间想象可能有点难度，我把整个场景投影在xy坐标系。图中的蓝线代表墙，origin就原点，黄色箭头代表小球的运动方向，v代表当前小球的位置用向量v(x,y,z)代表，u(x,y,z)代表墙角的位置，n代表墙的法线（我把它画在左边是为了让你能够清晰看到角度a）。用v+u便得到从小球当前位置到墙角的向量，那么它与法线n的夹角a便是我们所要关心的！当然这里的a指的是两个三维向量之间的夹角。设当时间为1sec时夹角为a0，时间为2sec时夹角为a1，从图中可以看出a0<a1！（因为小球向墙的方向移动）再想象一下，当小球移动到墙上的时候夹角就是90度。如果小球继续向右移动的话，那么夹角会继续增大。

关于向量点乘积（Dot product）计算的公式：

v0•v1=|v0||v1|cos(a) （|v0|和|v1|分别是向量v0和v1的大小）

两个向量的乘积等于两个向量的大小相乘再乘以它们夹角的余弦。当一个角度在0到90度范围内，那么这个夹角的余弦值为正数，当这个角度在90到180的范围内，它的余弦值为负数。有没有看出什么呢？也就是说当小球向右运动还未碰到墙时，a的值为正值，如果小球中心在墙上，a的值为cos(PI/2) = 0，当小球越过墙的话，a的值为负值。根据点乘积公式v0•v1=|v0||v1|cos(a)，可以推断v0•v1与cos(a)成正比并且符号相同。也就是说v+u向量和墙的法线n的点乘积为正时，小球还未碰到墙面，为负时小球已经越过墙面，乘积为0时，小球在墙面上。（我这里说的墙面的法线是垂直于墙面的向量）Great!

再加深一下印象，下面是目前所述内容的伪代码：

VECTOR3D position_current

VECTOR3D position_after

VECTOR3D velocity

VECTOR3D uv_before = VectorAddition(position_current, wall_corner)

SCALAR before = VectorDotProduct(uv_before, normal_wall);

VECTOR3D position_after = VectorAddition(current_position, velocity)

VECTOR3D uv_after = VectorAddition(position_after, wall_corner)

SCALAR after = DotProduct(uv_after, normal_wall);

IF before > 0 AND after < 0 THEN COLLIDE

IF before < 0 AND after > 0 THEN COLLIDE

不足为奇，上面我所说的方法只是其中一种方法实现检测碰撞，这里再简单说一另外一个方法：当小球球心在平面上时，那么设球心与多边行任意两个夹角分别为a0,a1...an，那么a0+a1+...an的值就应该为360，运用这种角度检测的方法也可以得到想要得结果。当然还有很多其他的测定碰撞方式，我就不再一一叙述。



夹角求和方式判定是否碰撞

我写了一个例子说明我们是运用第一个算法检测碰撞的。你可以在文章尾找到例子源文件的下载链接。你所要做的就是使用Visual C++新建立一个空的项目，然后把vector.h和main.cpp添加到项目里，然后编译。这个例子演示了一个小球在两个四边形中间来回运动，当撞击到其中一个平面后便会相反的方向移动。你可以点击托拽鼠标来转动物体，按下键盘的A键来确定是否在小球撞击到四边形后变化小球运动方向。

程序步骤

下面我详细讲解一部分代码：

1. 首先你需要写一个Vector3D类，代表三维空间的向量（当然不需要非常复杂）。关于这个类我就打算在这篇文章详细的解释了。

#ifndef __VECTOR3D__

#define __VECTOR3D__

#include "math.h"

///////////////////////////////////////////////////////////////////////////

// vector class

class Vector3D

{

public:

float x;

float y;

float z;

///////////////////////////////////////////////////////////////////////////

// constructor

Vector3D() { x = 0.0f; y = 0.0f; z = 0.0f; }

Vector3D(const Vector3D &v) { x = v.x; y = v.y; z = v.z; } // copy constructor

Vector3D(float x, float y, float z) { this->x = x; this->y = y; this->z = z; }

///////////////////////////////////////////////////////////////////////////

// operator overloading

Vector3D& operator = (Vector3D v) { x = v.x; y = v.y; z = v.z; return *this; }

Vector3D operator + (Vector3D v) const { return Vector3D(x+v.x, y+v.y, z+v.z); }

Vector3D operator - (Vector3D v) const { return Vector3D(x-v.x, y-v.y, z-v.z); }

Vector3D operator * (float scalar) const { return Vector3D(x*scalar, y*scalar, z*scalar); }

Vector3D operator / (float scalar) const { return Vector3D(x/scalar, y/scalar, z/scalar); }

Vector3D operator - () { return Vector3D(-x, -y, -z); }

bool operator == (const Vector3D &v) const { return x==v.x && y==v.y && z ==v.z; }

bool operator != (const Vector3D &v) const { return x!=v.x || y!=v.y || z!=v.z; }

Vector3D& operator += (Vector3D v) { x += v.x; y += v.y; z += v.z; return *this; }

Vector3D& operator -= (Vector3D v) { x -= v.x; y -= v.y; z -= v.z; return *this; }

Vector3D& operator *= (Vector3D v) { x *= v.x; y *= v.y; z *= v.y; return *this; }

Vector3D& operator /= (Vector3D v) { x /= v.x; y /= v.y; z /= v.y; return *this; }

inline float dot (Vector3D & v) { return x*v.x + y*v.y + z*v.z; }

///////////////////////////////////////////////////////////////////////////

// vector functions

void zero(){ x = y = z = 0.0f; }

float mag() { return sqrt(x*x+y*y+z*z); }

float operator * (const Vector3D &v) const { return x*v.x+y*v.y+z*v.z; }

void normalize()

{

float mag = this->mag();

if (mag ==0)

return;

x /= mag;

y /= mag;

z /= mag;

}

Vector3D normal()

{

float mag = this->mag();

if (mag ==0)

return Vector3D(0, 0, 0);

return Vector3D(x/mag, y/mag, z/mag);

}

};

#endif

2. 在例子里，我使用了OpenGL的绘图引擎。程序一开始一些设置和初始化全局变量的代码（通常不会做太大的变化）。

#include <iostream>

#include <windows.h>

#include <stdio.h>

#include <stdlib.h>

#include <gl/glut.h>

#include "vector.h"

using namespace std;

#define APP_WIDTH 640 // specify the width of the app window

#define APP_HEIGHT 480 // specify the height

#define APP_INIT_X 200 // specify the initial x

#define APP_INIT_Y 200 // specify the initial y

// an rgb struct

typedef struct tagRGB { float r, g, b; } RGB;

// a quad struct

typedef struct tagQuad { Vector3D vertices[4]; Vector3D normal; RGB color; } QUAD;

float _rotationy = 90.0f; // rotate objects around y axis

float SPHERE_RADIUS = 0.4f; // radius of our ball

bool _pre_check = false; // not let the ball pass through the plane

Vector3D _sphere_pos = Vector3D(0.0f, 0.0f, 0.0f); // position of our ball 1

Vector3D _velocity = Vector3D(0.0f, 0.0f, 0.02f); // moving velocity of our ball

GLUquadricObj * _quadric = gluNewQuadric(); // used to create a sphere

QUAD _quads[2];

bool _drag = false; // click on the screen and start drag

int _dragx; // current mouse x

int _dragy; // current mouse y

3. 下面设置鼠标和键盘响应的事件。

// handle the keyboard press event

void handleKeyEvent(unsigned char key, int x, int y)

{

switch (key)

{

case 'a':

_pre_check = !_pre_check;

printf("Toggle check.\n");

break;

default:

break;

}

}

// handle the mouse press and release event

void mouseEvent(int button, int state, int x, int y)

{

if (button == 0) // mouse left

{

if (state == 0) // pressed

{

_drag = true;

_dragx = x;

}

if (state == 1) // released

{

_drag = false;

}

}

}

// handle the mouse move event

void motionEvent(int x, int y)

{

if (_drag)

{

_rotationy += x-_dragx;

_dragx = x;

}

}

4. 初始化OpenGL绘制设置，包括氛围和灯光等。另外还要写一个函数处理当你缩放窗口的响应事件。

int init()

{

glEnable(GL_DEPTH_TEST);

glEnable(GL_NORMALIZE);

glEnable(GL_LIGHTING);

glEnable(GL_LIGHT0);

glEnable(GL_LIGHT1);

glEnable(GL_DEPTH_TEST);

glEnable(GL_COLOR_MATERIAL);

GLfloat ambientColor[] = { 1.0f, 1.0f, 1.0f, 0.1f }; // setup ambient light

glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambientColor);

GLfloat lightColor0[] = { 1.0f, 1.0f, 1.0f, 1.0f }; // setup a light

GLfloat lightPos0[] = { 2.0f, 20.0f, 20.0f, 1.0f };

glLightfv(GL_LIGHT0, GL_DIFFUSE, lightColor0);

glLightfv(GL_LIGHT0, GL_POSITION, lightPos0);

return true;

}

// this is called when you resize the app

void handleResize(int width, int height)

{

glViewport(0, 0, width, height);

glMatrixMode(GL_PROJECTION);

glLoadIdentity();

gluPerspective(45.0f, (double)width / (double)height, 1.0, 200.0);

}

5. 下面是布置场景的函数display()，函数完成功能是简单的绘制两个四边形一个在前面，另外一个在后面，中间绘制一个小球。然后我让整个场景围绕y轴旋转90度，有一个更好的观看角度。

// draw the objects on the screen

void display()

{

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

glMatrixMode(GL_MODELVIEW);

glLoadIdentity();

glTranslatef(0.0f, 0.0f, -20.0f); // move objects further

glRotatef(_rotationy, 0.0f, 1.0f, 0.0f); // rotate obejcts around y axis

glPushMatrix();

glBegin(GL_QUADS); // draw left and right plane

for (int i = 0; i < 2; i++)

{

glColor3fv((const float *)&_quads[i].color);

for (int v = 0; v < 4; v++)

{

glVertex3f(_quads[i].vertices[v].x, _quads[i].vertices[v].y, _quads[i].vertices[v].z);

}

}

glEnd();

glPopMatrix();

glColor3f(0.2f, 0.4f, 0.9f); // color of our ball

glPushMatrix();

// move the ball to the position specified at the beginning

glTranslatef(_sphere_pos.x, _sphere_pos.y, _sphere_pos.z);

gluSphere(_quadric, SPHERE_RADIUS, 50, 50); // draw the ball

glPopMatrix();

glutSwapBuffers();

}

6. 下面是小球运动的循环函数，这里的算法即是前面所讨论到的。

void move()

{

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

glMatrixMode(GL_MODELVIEW);

glLoadIdentity();

bool collision = false;

// calculate the position where the ball should be

Vector3D post_pos = _sphere_pos+_velocity;

for (int i = 0; i < 2; i++)

{

// slope between the normal of the plane and the ball position

// to the right plane, if the ball center is on the plane,

// then the slope should be acos(0) which is pi/2 radian, if it is not yet reach the plane

// then the sploe should be acos(angle) where angle is greater than pi/2 radian

// this means the the slope is less than 0, vice versa

float d_before = (_sphere_pos + _quads[i].vertices[0]).dot(_quads[i].normal);

float d_after = (post_pos + _quads[i].vertices[0]).dot(_quads[i].normal);

if (_pre_check)

{

if (abs(d_after) < SPHERE_RADIUS)

{

printf("The sphere is close to the %s plane\n", i == 0 ? "left" : "right");

collision = true;

}

}

else

{

// if there is a sign change

if ((d_before>0 && d_after<0) || (d_before<0 && d_after>0))

{

printf("The sphere passed the %s plane\n", i == 0 ? "left" : "right");

collision = true;

}

}

}

if (!collision)

_sphere_pos = post_pos; // if not collide with the plane

else

_velocity = -_velocity; // move opposite way

glutPostRedisplay();

}

7. 写好接口main函数，那么整个程序就完成了。

void main(int argc, char** argv)

{

glutInit(&argc, argv);

glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);

glutInitWindowSize(APP_WIDTH, APP_HEIGHT);

glutInitWindowPosition(APP_INIT_X, APP_INIT_Y);

glutCreateWindow("Collision Detection");

// here we create specify two planes, one is on the left and another one is on the right

_quads[0].color.r = 0.9f;

_quads[0].color.g = 0.2f;

_quads[0].color.b = 0.2f;

_quads[0].vertices[0] = Vector3D(-2.0f, -2.0f, -7.0f);

_quads[0].vertices[1] = Vector3D(2.0f, -2.0f, -7.0f);

_quads[0].vertices[2] = Vector3D(2.0f, 2.0f, -7.0f);

_quads[0].vertices[3] = Vector3D(-2.0f, 2.0f, -7.0f);

_quads[0].normal = Vector3D(0.0f, 0.0f, 1.0f); // the normal is diagonal to the plane

_quads[1].color.r = 0.2f;

_quads[1].color.g = 0.9f;

_quads[1].color.b = 0.2f;

_quads[1].vertices[0] = Vector3D(-2.0f, -2.0f, 7.0f);

_quads[1].vertices[1] = Vector3D(2.0f, -2.0f, 7.0f);

_quads[1].vertices[2] = Vector3D(2.0f, 2.0f, 7.0f);

_quads[1].vertices[3] = Vector3D(-2.0f, 2.0f, 7.0f);

_quads[1].normal = Vector3D(0.0f, 0.0f, 1.0f); // the normal is diagonal to the plane

gluQuadricNormals(_quadric, GLU_SMOOTH);

init();

glutDisplayFunc(display);

glutIdleFunc(move);

printf("Program started...\n");

glutKeyboardFunc(handleKeyEvent);

glutMouseFunc(mouseEvent);

glutMotionFunc(motionEvent);

glutReshapeFunc(handleResize);

glutMainLoop();

}

我希望在看完这篇文章后你有所收益，举一反三，so，加油！

非常抱歉，文中暂时不提供源文件下载，如果你需要源文件，请来信或者留言给我。笔者利用工作之余写这些文章，付出了很多汗水，希望读者和转载者能够尊重作者的劳动。

作者：Yang Zhou 出处：http://yangzhou1030.cnblogs.com 本文版权归作者和博客园共有，转载未经作者同意必须保留此段声明。请在文章页面明显位置给出原文连接，作者保留追究法律责任的权利。