# Collision Detection 1 - Temple University

Document Sample

```					    CIS 350 – I

Game Programming
Instructor: Rolf Lakaemper
Introduction
To
Collision Detection
Parts of these slides are based on
www2.informatik.uni-wuerzburg.de/ mitarbeiter/holger/lehre/osss02/schmidt/vortrag.pdf
by Jakob Schmidt
What ?

The problem:

The search for intersecting planes of
different 3D models in a scene.

Collision Detection is an important
problem in fields like computer
animation, virtual reality and game
programming.
Intro

The problem can be defined as

if, where and when

two objects intersect.
Intro

This introduction will deal with
the basic problem:

IF

two (stationary) objects
intersect.
Intro

The simple solution:

Pairwise collision check of all
of.
Intro

Problem:

• complexity O(n²)

• not acceptable for reasonable
number n of polygons

• not applicable for realtime
application
Bounding Volumes

Part 1: Bounding Volumes

Reduce complexity of collision
computation by substitution of
the (complex) original object
with a simpler object
containing the original one.
Bounding Volumes

The original objects can only
intersect if the simpler ones
do. Or better: if the simpler
objects do NOT intersect, the
original objects won‟t either.
Bounding Volumes

How to choose BVs ?

• Object approximation behavior („Fill
efficiency‟)
• Computational simplicity
• Behavior on (non linear !)
transformation (incl. deformation)
• Memory efficiency
Bounding Volumes

Different BVs used in game
programming:

• Axes Aligned Bounding Boxes (AABB)
• Oriented Bounding Boxes (OBB)
•Spheres
• k-Discrete Oriented Polytopes (k DOP)

AABB      Sphere   OBB   k-DOP
Bounding Volumes

Axes Aligned Bounding Box (AABB)

• Align axes to the
coordinate system
• Simple to create
• Computationally efficient
• Unsatisfying fill efficiency
• Not invariant to basic
transformations, e.g.
rotation
Bounding Volumes

Axes Aligned Bounding Box (AABB)

Collision test: project BBs
onto coordinate axes. If
they overlap on each axis,
the objects collide.
Bounding Volumes

Oriented Bounding Box (OBB)

Align box to object such that it fits optimally
in terms of fill efficiency

Computationally expensive
Invariant to rotation
Complex intersection check
Bounding Volumes

The overlap test is based on the

Separating Axes Theorem
(S. Gottschalk. Separating axis theorem. Technical Report TR96-024,Department
of Computer Science, UNC Chapel Hill, 1996)

Two convex polytopes are disjoint iff there
exists a separating axis orthogonal to a face
of either polytope or orthogonal to an edge
from each polytope.
Bounding Volumes

Each box has 3 unique face orientations, and
3 unique edge directions. This leads to 15
potential separating axes to test (3 faces from
one box, 3 faces from the other box, and 9
pairwise combinations of edges).
Bounding Volumes

Sphere

• Relatively complex to compute
• Simple overlap test
• invariant to rotation
Bounding Volumes

K-DOP

•Easy to compute
•Good fill efficiency
•Simple overlap test
•Not invariant to rotation
Bounding Volumes

k-DOP is considered to be a trade off
between AABBs and OBBs.

Its collision check is a general version of
the AABB collision check, having k/2
directions
Bounding Volumes

k-DOPs are used
e.g. in the game

„Cell Damage‟
(XBOX, Pseudo
Interactive, 2002)
Bounding Volumes

How to Compute and Store k-DOPs:

k-directions
k-directions Bi define halfplanes (they are
the normals to the halfplanes) , the
intersection of these halfplanes defines
the k-DOP bounding volume.

Halfplane Hi = {x | Bi x – di <= 0}
Bounding Volumes

3D Example: UNREAL-Engine
Bounding Volumes

2D Example for halfplanes defining a
k-DOP

Normal vector   Bi
Bounding Volumes

Again: halfplane Hi = {x | Bi x – di <= 0}

•If the directions Bi are predefined, only
the distances di must be stored to specify
the halfplane Hi . This is one scalar value
per direction.

•If the directions are NOT predefined, Bi
and di must be stored (3D case: 4 values)
Bounding Volumes

How to compute di :

Hessian Normal Form
( Bx – d = 0 with d = Bp) with
unit vector
of a plane automatically gives
distance d if a single point p on
the plane is known.
Bounding Volumes

Compute distances of all vertices to plane
Bx = 0, i.e. multiply (dot product) each
vertex with the unit normal vector B

Unit vector B

Bx = 0
Bounding Volumes

di is the minimum distance of the
object to the plane Bx = 0

Bx = 0
di
Bounding Volumes

Collision
Given: k non kollinear directions Bi and
V = set of vertices of object.

Compute di = min{Bi v| v in V } and
Di = max{Bi v| v in V}. di and Di define an
interval on the axis given by Bi .

This is the interval needed for the
collision detection !
Bounding Volumes

Collision

D1

Plane defined by B1                Interval [d1, D1] defined by B1

B1     d1
Bounding Volumes

Part 2: Collision on different scales:

Hierarchies
Hierarchies

Idea:

To achieve higher exactness in
collision detection, build a
multiscale BV representation
of the object
Hierarchies
Hierarchies

Use the hierarchy from coarse to fine
resolution to exclude non intersecting
objects
Hierarchies

The hierarchy is stored in a tree, named
by the underlying BV scheme:

AABB – tree
OBB – tree
Sphere – tree
kDOP – tree
Hierarchies

Sphere Trees are used for
example in
“Gran Tourismo”
Hierarchies

Simple example:

• Binary tree
• Each node contains all
primitives of its subtree
• Leaves contain single
primitive
Hierarchies
Hierarchies
Hierarchies

Recursive
Collision                     )
Detection

Returns TRUE if BBs
overlap.
How could this be improved
to give a precise overlap test ?
Hierarchies
Hierarchies

How to create a hierarchy tree
Top down:

• Use single BV covering whole object
• Split BV
• Continue recursively until each BV
contains a single primitive
Hierarchies

Bottom up:

• Merge
Hierarchies

Example for top down using OBBs :
Hierarchies

Comparison AABB / OBB
Multiple Objects

Part 3: Collision between

Multiple Objects
Multiple Objects

Virtual environment usually consists of more
than 2 objects. Pairwise detailed collision
between all objects is too slow. Solution again:

1. Exclude non colliding objects
2. Check collision between remaining
objects
Multiple Objects

Methods to exclude non colliding objects:

1.Grid Method
Or
2. Sort and Sweep (AABB)
Multiple Objects

Grid Method:
Create 3d grid volume overlay

Only check collision between objects
sharing at least one cell
Multiple Objects

2D example
Multiple Objects

Sort and Sweep
• Create single AABB for each object

• Project BVs onto coordinate axes

• Create a sorted list of start and endpoints for
each coordinate axis, hence store the
intervals created by each object

(Cont‟d)
Multiple Objects

• Traverse each list
• If startpoint of object i is hit, insert i into
„active list‟
• If endpoint of object i is hit, remove i from
„active list‟
• If 2 objects i1,i2 are active at the same time
they overlap in the dimension processed
• Objects overlapping in all single dimensions
overlap in world
Multiple Objects

s3
X     Y
s1
S3   S1
3            S1   S2
e3
1                               E3   E1
s2                                                 S2   S3
e1                                                 E1   E2
2                E2   E3
e2

OVERLAP 1,2
s1       s2 e1 s3           e2 e3
Multiple Objects

Note: sort and sweep for a single step is
relatively expensive.

Since not all objects are transformed for the
next frame, the list is not created newly for
each frame, but updated.

```
DOCUMENT INFO
Shared By:
Categories:
Stats:
 views: 3 posted: 5/7/2011 language: English pages: 53