Detekcija trkov
Detekcija trkov
Pomen detekcije trkov
Especially important in Interactive Virtual Environments.
No matter how good the VE look, the poor realism resulting from a lack of collision detection.
However, there may be hundreds, even thousands of objects in the virtual world.
Pomen detekcije trkov
Uvod
Kaj je odkrivanje trkov?
Entities occupy, partially or fully, the same location at the same time.
We term the above scenario a collision. Collision leads to event(s) in most cases –
– Bullet hitting a box of grenades causing the event of explosion and possibly other events (e.g., reduction of life force for players stood near the grenades at time of explosion).
However, this is not the full story –– Ideally we should foresee collision as immanent and time
our event to occur at a deterministic point in time (true collision).
– Q: How is this achieved while still maintaining performance?– A: With great difficulty when performance permits.
Trki
Odkrivanje trkov
Essential for many games Shooting Kicking, punching, beating, whacking, smashing,
hitting, chopping, dicing, slicing, julienne fries… Car crashes
Expensive tests!!
)( 2NO
Demo
Problem N teles
Različne vrste teles, ki trkajo
Uporaba odkrivanja trkov
Determining if the player or character has a hit a wall or obstacle To stop them walking through it
Determining if a projectile (missile) has hit a target
Detecting points at which behavior should change A car in the air returning to the ground
Cleaning up animation Making sure a character’s feet do not pass through the floor
Simulating motion of some form E.g. cloth, or something else
Odkrivanje trkov
Collision detection, as used in the games community, usually means intersection detection of any form
Intersection detection is the general problem: find out if two geometric entities intersect – typically a static problem
Interference detection is the term used in the solid modeling literature – typically a static problem
Collision detection in the research literature generally refers to a dynamic problem – find out if and when moving objects collide
Subtle point: Collision detection is about the algorithms for finding collisions in time as much as space
Terminologija
Convex Concave
An object is convex if for every pair of points inside the object, the line joining them is also inside the object
Manifold Non-Manifold
An surface is manifold if every point on it is homeomorphic to a disk.Roughly, every edge has two faces joining it
Izbira algoritma
The geometry of the colliding objects is the primary factor in choosing a collision detection algorithm– “Object” could be a point, or line segment
– Object could be specific shape: a sphere, a triangle, a cube, …
– Objects can be concave/convex, solid/hollow, deformable/rigid
The way in which objects move is a second factor– Different algorithms for fast or slow moving objects
– Different algorithms depending on how frequently the object must be updated
Of course, speed, simplicity, robustness are all other factors
Strategije odkrivanja trkov
There are several principles that should be considered when designing a collision detection strategy
What might they be?– Say you have more than one test available, with
different costs. How do you combine them?
– How do you avoid unnecessary tests?– How do you make tests cheaper?
Strategije odkrivanja trkov
There are several principles that should be considered when designing a collision detection strategy
Fast simple tests first to eliminate many potential collisions
– e.g.: Test bounding volumes before testing individual triangles
Exploit locality to eliminate many potential collisions
– e.g.: Use cell structures to avoid considering distant objects
Use as much information as possible about the geometry
– e.g.: Spheres have special properties that speed collision testing
Exploit coherence between successive tests
– Things don’t typically change much between two frames
Robustnost
For our purposes, collision detection code is robust if it:
– Doesn’t crash or infinite loop on any case that might occur
• Better if it doesn’t crash on any case at all, even if the case is supposed to be “impossible”
– Always gives some answer that is meaningful, or explicitly reports that it cannot give an answer
– Can handle many forms of geometry
– Can detect problems with the input geometry, particularly if that geometry is supposed to meet some conditions (such as convexity)
Robustness is remarkably hard to obtain
Odkrivanje trkov
Efficiency hacks/cheats– Fewer tests: Exploit spatial coherence
• Use bounding boxes/spheres
• Hierarchies of bounding boxes/spheres
Tipi geometrije
Points Lines, Rays and Line Segments Spheres, Cylinders and Cones Cubes, rectilinear boxes - Axis aligned or arbitrarily aligned
– AABB: Axis aligned bounding box– OBB: Oriented bounding box
k-dops – shapes bounded by planes at fixed orientations Convex, manifold meshes – any mesh can be triangulated
– Concave meshes can be broken into convex chunks, by hand
Triangle soup More general curved surfaces, but not used (often) in games
8-dop
AABB
OBB
Collision Detection using Bounding Spheres (Boxes)
If the bounding spheres (boxes) of two objects don’t intersect, there is no collision between the two object.– How to determine the intersection between spheres / boxes?
If the bounding volumes intersect, there may be collision between the objects.– However, there may still be no collision.
– Tight bounds performs better. We may treat two objects collided if the bounds are tight and intersect.
Not every object has a good bounding sphere (box), e.g. planes.
Primeri obsegajočih volumnov
Primeri obsegajočih volumnov
Obsegajoča krogla in kvader
Bounding sphere: the minimum sphere enclosing the object.– You may need to find the center of the object and the radius of
the sphere. (can be done in the modeling phase)
– Not accurate in may cases. But can be used as initial test before applying more complicated algorithms.
– Not a good fit for narrow or long objects
Bounding box (axis-aligned): the minimum and maximum coordinates of the object in x, y, z directions– Not transform-invariant. Need to be recomputed after a
transformation, e.g. rotation.
– Can fit odd shaped objects better
Obsegajoči kvader (bounding box)
Place a box around an object– Box should completely enclose the object and be of
minimal volume– Fairly simple to construct
Test intersections between the boxes to find intersections
Each box has 6 faces (planes) in 3D– Simple algebra to test for intersections between
planes– If one of the planes intersects another, the objects are
said to collide
Obsegajoči kvader
Space complexity– Each object must store 8 points representing the
bounding box– Therefore, space is O(8) and Ω(8)
Time complexity– Each face of each object must be tested against each
face of each other object– Therefore, O((6n)2) = O(n2)
• n is the number of objects
Obsegajoči kvader
Pro– Very easy to implement
– Very little extra space needed
Con– Very coarse detection
– Very slow with many objects in the scene
Obsegajoče krogle (Bounding Spheres)
Similar to bounding boxes, but instead we use spheres– Must decide on a “center” point for the object
that minimizes the radius– Can be tough to find such a sphere that
minimizes in all directions– Spheres could leave a lot of extra space
around the object!
Obsegajoče krogle
Each sphere has a center point and a radius– Can build an equation for the circle– Simple algebra to test for intersection
between the two circles
Obsegajoče krogle
Space complexity– Each object must store 2 values - center and radius -
to represent the sphere– Therefore, space is O(2) and Ω(2)– Space is slightly less than bounding boxes
Time complexity– Each object must test it’s bounding sphere for
intersection with each other bounding sphere in the scene
– Therefore, O(n2)• n is the number of objects
– Significantly fewer calculations than bounding boxes!
Obsegajoče krogle
Pro– Even easier to implement (than bounding boxes)– Even less space needed (than bounding boxes)
Con– Still fairly coarse detection– Still fairly slow with many objects
Poravnani obsegajoči kvadri (Aligned Bounding Boxes)
Axis-aligned vs. Object-aligned
Axis-aligned BBox change as object moves
Approximate by rotating BBoxSwept volume
Oriented Bounding Boxes (OBBs)
These are more difficult to implement and result in greater effort to achieve collision detection. However, the collision detection is more accurate than AABBs.
Furthermore, because the OBBs are expected to “fit” more tightly around an entity the tree structure is expected to be much reduced over that of AABBs.
Checking for OBBs that are collided means ensuring that no separating axis exist (same as AABBs). However, in 3D there are 15 potential axes. Furthermore, the axes do not lie trivially on regular planes (X, Y, Z) but must be deduced from the orientation of the OBBs involved.– Handling OBBs in three dimensions are beyond the scope of this
course.– AABBs are adequate for our purposes.
Hierarhije obsegajočih volumnov
Izgradnja hierarhije
Hierarhije za trdna telesa
Optimization Structures
BV, BVH (bounding volume hierarchies) Octree KD tree BSP (binary separating planes) OBB tree (oriented bounding boxes- a popular
form of BVH) K-dop Uniform grid
Testing BVH’s
TestBVH(A,B) if(not overlap(ABV, BBV) return FALSE;
else if(isLeaf(A)) if(isLeaf(B)) for each triangle pair (Ta,Tb)
if(overlap(Ta,Tb)) AddIntersectionToList();
else for each child Cb of B
TestBVH(A,Cb);
else
for each child Ca of A
TestBVH(Ca,B)
Bounding Volume Hierarchies
Octrees
KD Trees
BSP Trees
OBB Trees
K-Dops
Uniform Grids
BSP Trees
BSP (Binary Space Partitioning) trees are used to break a 3D object into pieces for easier comparison– Object is recursively broken into pieces and
pieces are inserted into the tree– Intersection between pieces of two object’s
spaces is tested
BSP Trees
We refine our BSP trees by recursively defining the children to contain a subset of the objects of the parent– Stop refining on one of a few cases:
• Case 1: We have reached a minimum physical size for the section (ie: one pixel, ten pixels, etc)
• Case 2: We have reached a maximum tree depth (ie: 6 levels, 10 levels, etc)
• Case 3: We have placed each polygon in a leaf node• Etc… - Depends on the implementer
BSP Trees
Example BSP Tree
BSP Trees
Example BSP Tree
BSP Trees
Example BSP Tree
BSP Trees
Example BSP Tree
BSP Trees
Collision Detection– Recursively travel through both BSP trees checking if
successive levels of the tree actually intersect• If the sections of the trees that are being tested have
polygons in them:– If inner level of tree, assume that an intersection occurs and
recurse– If lowest level of tree, test actual intersection of polygons
• If one of the sections of the trees that are being tested does not have polygons in it, we can surmise that no intersection occurs
BSP Trees
Space Complexity– Each object must store a BSP tree with links to
children– Leaf nodes are polygons with geometries as integer
coordinates
– Therefore, space depends on number of levels of tree, h, and number of polygons (assume convex triangles - most common), n
– Therefore, space is O(4h + 3n) and Ω(4h + 3n)
BSP Trees
Time Complexity– Each object must be tested against every
other object - n2
– If intersection at level 0, must go through the tree - O(h)
• Assume all trees of same height
– Depends on number of intersections, m– Therefore, O(n2 + m*h) and Ω(n2)
BSP Trees
Pros– Fairly fine grain detection
Cons– Complex to implement– Still fairly slow
– Requires lots of space
Using a sphere
We surround our entity with a large enough sphere to ensure that collisions (in the most part) are detected.
• When projected into consecutive frames, the spheres should overlap.
• This ensures we cover the whole (well nearly whole) scope of the possible collision.
• We check if the distance between the two centres of the spheres is less than the sum of the radii.
• However, while the calculations are simple, the results can look poor on screen (collision events may occur when the user actually views no collision).
More precise detection
When entities are an irregular shape, a number of spheres may be used.
• In this diagram we use three spheres for greater accuracy.
• Geometry in games may be better suited to bounding boxes (not circles).
• To ease calculations, bounding boxes are commonly axis aligned (irrelevant of entity transformations they are still aligned to X, Y and Z coordinates in 3D) These are commonly called AABBs (Axis Aligned Bounding Boxes).
Recursive testing of bounding boxes
We can build up a recursive hierarchy of bounding boxes to determine quite accurate collision detection.
• Here we use a sphere to test for course grain intersection.• If we detect intersection of the sphere, we test the two sub
bounding boxes.
• The lower bounding box is further reduced to two more bounding boxes to detect collision of the cylinders.
Tree structure used to model collision detection
A recursive algorithm can be used to parse the tree structure for detecting collisions.
If a collision is detected and leaf nodes are not null then traverse the leaf nodes.
If a collision is detected and the leaf nodes are null then collision has occurred at the current node in the the structure.
If no collision is detected at all nodes where leaf nodes are null then no collision has occurred (in our diagram B, C or D must record collision).
A B
C
D
E
A
B C
D E
Speed over accuracy
The approach which offers most speed would be to have AABBs of a size fixed at entity initialization time.– That is, irrelevant of entity transformation the associated
AABB does not change in size or shape.
This is cumbersome for entities shaped like cylinders.– Plenty of “free space” will exist around the cylinder.
For more realistic collision detection the bounding box may fit closely to the entity and rotate along with associated entity.– This requires the bounding box to be recomputed every time
an entity is rotated.
Optimization Structures
All of these optimization structures can be used in either 2D or 3D
Packing in memory may affect caching and performance
Collision Detection
For each object i containing polygons p– Test for intersection with object j with
polygons q– (j > i)
For polyhedral objects, test if object i penetrates surface of j– Test if vertices of i straddle polygon q of j
• If straddle, then test intersection of polygon q with polygon p of object i
Dimension Reduction
If two bodies collide in 3-D space, their orthogonal projections onto the xy, yz, and xy planes, and x, y, and z axes must overlap.
Two AABB intersect, if and only if their projections onto all three axis intersect.– This is why the bounding boxes are axis aligned.
1-D Sweep and Prune (projection onto x, y, z axes)
2D Intersection tests (projection onto xy, yz, xz planes)
X
Y
Očrtani pravokotniki in odkrivanje trkov
Box A moves to overlap box B
Dimension reduction
1-D Sweep and Prune
Bounding Volumes projected onto x, y, and z axes Have one sorted list for each dimension Maintain Boolean flag which only changes if swaps are
made on sorted lists.– An upper-triangular O(n2) matrix
1-D Sweep and Prune
If flags are true for all 3 dimensions,– we pass this pair on to exact collision detection.
Due to temporal coherence, individual lists are likely almost sorted already.
Insertion sort works well where large numbers of objects move locally.– O(n+s), where s is the number of pairwise overlaps
2D Intersection Tests
Bounding Volumes projected onto xy, yz, and zx planes– Three 2D rectangles instead of 1D intervals
Maintain the interval tree for performing 2D range queries [
Multi-Body Problems
Multi-body problems have many objects that could be colliding– Most common case in games is lots of players or agents– “Collision” may not mean intersecting, could just mean
being close enough to react It is essential to avoid considering every pair (n2 cost) Spatial subdivision schemes provide one solution
– Object interactions are detected in a two step process: which cell am I in, then who else is in my cell?
– Many possible spatial subdivision data structures: fixed grid, Octrees, Kd-trees, BSP trees, …
Bounding volume schemes provide another solution– Hierarchies of bounding volumes
Bounding Volume Hierarchies
Basic idea is to build a tree where each level of the tree bounds its children
– Group objects in a hierarchical structure (tree), and recursively build bounding volume for each tree node to form a hierarchy of bounding volumes.
– Most common bounding volumes are axis-aligned boxes or spheres
– Generally used for large numbers of static obstacles and a few moving things
• Put all the static obstacles into the tree
• Test for intersection between moving object and tree
Intersection test against a bounding volume hierarchy: recursively traverse the tree, skip the subtree if the bounding volumes don’t intersect. A collision occurs if a leaf node’s bounding volume intersect with the test object.
The major difference is that a bounding volume hierarchy does not subdivide all of space, only those parts of space that are occupied
Bounding Tree Example
Bounding Volume Hierarchy Example
Architecture for Multi-body Collision Detection
Pruning Multi-body Pairs
N moving objects + M static objects
Objective– to reduce the number of pairs of objects that are actually
compared, to give O(N+M) Use coherence
– By sorting objects in 3-space– Assumes each object is surrounded by a 3-D bounding volume
(AABB) Use Dimension Reduction to sort the objects in 3-space
3-D Bounding Volumes
Types– Fixed-Size Bounding Cubes
• Recalculating fixed size bounding cubes add less overhead, as their size remains constant.
– Dynamically-Resized Rectangular bounding bounding boxes.
• Dynamically resized bounding boxes are the “tightest” axis-aligned box containing the object at a particular orientation.
• More overhead due to recomputation of min, max x,y,z values
R
Architecture for Multi-body Collision Detection
Pairwise Collision Detection for Convex Polytopes
The Lin-Canny collision detection algorithm– Tracks closest points
between pairs of convex polytopes
– Gives closest features even if objects do not intersect
Collision Detection
Discretization in 3D Create a voxel array
– Store an ID in each voxel where an object is
– Collision where voxel has an ID already
– Difficult to determine good voxel size
– Huge memory– Hash table -- gives constant time point queries
Inter-Object Distance
A related problem:– Collision Avoidance
Part of motion planning is to avoid collisions Many collision detection algorithms take time into
account Estimate Collision Time, distance www.cs.unc.edu/~geom/collision.html
Cheaper distance calculation:
– Compare against
Approximation:
– Manhattan distance - Shortest side/2
))()(( 221
221 yyxxsqrtd −+−=
Collision Detection
)()( 2121 yyabsxxabsd −+−=
2d
5.55.143'
54,3
=−+==→==
d
ddydx
2/))(),(min( 2121 yyabsxxabs −−−
So far, no interaction between rigid bodies
Bodies in Collision Collisions and Contact
Collision detection – determining if, when and where a collision occurs
Collision response – calculating the state (velocity, …) after the collision
A problem with frame rate and collision
An entity moves around the screen at a given speed. This speed may be increasing, decreasing (accelerating or decelerating) or may be static.
If the speed of an entity is such that the distance moved on screen is sufficiently large per frame rate, then simply identifying if vertices cross is not an appropriate solution.– They may never cross!
Frame 1 Frame 2
Solid wallEntity
Possible solutions – Projecting bounding box.
Produce bounding box around an entity at current frame and next frame position (look ahead) and check collisions using this new shape.
• For this method to work we are actually carrying out twice as much detection as required. This is very time consuming and will possibly reduce performance (even slower frame rate).
Considering time in collision detection
Assume entities E1 and E2 are displayed in different positions at the following frame times t1, t2 (giving the illusion of motion).
E1 E2 E2 E1
t1 t1
• We know they collided, but as far as the display is concerned no collision has occurred. (they have passed through each other).• We need to introduce the notion of time into our equations to aid
collision detection.
Possible solutions – Using time in our equations
Use a recursive algorithm to check for intersection at lower time intervals (even though these will not be displayed on screen).
Carry out our calculations in 4D (including time). This is complicated physics and computationally draining of valuable CPU time.
In real-time games (such as first person shooters) these types of calculations are just too intensive.
)( 3tx
)( 2tx
What should we do when there is a collision?
Collisions and Contact
)( 0tx
)( 1tx
Restart the simulation at the time of the collision
Rolling Back the Simulation
Collision time can be found by bisection, etc.
)( 3tx
)( 2tx
)( 0tx
)( 1tx
)( ctx
Precise Collision Times
Generally a player will go from not intersecting to interpenetrating in the course of a frame
We typically would like the exact collision time and place– Better collision response calculation– Interpenetration may be algorithmically hard to
manage– Interpenetration is difficult to quantify– A numerical root finding problem
More than one way to do it:– Hacked (but fast) clean up– Interval halving (binary search)
Collision Time
Given a ball at initial position p0 = (x1, x2, x3), with initial velocity v = (v1, v2, v3), and a constant acceleration a = (a1, a2, a3). When will it hit a plane f(x, y, z) = 0– p = p0 + vt + ½ at2– Solve the equation f(p) = 0
But it is the center of the ball that intersects the plane. To be more accurate, we can simply move the position so that the objects just touch, and leave the time the same. (Hacked clean up)
Multiple choices for how to move:– Back along the motion path– Shortest distance to avoid penetration
Interval Halving Example
t=0
t=1
t=0.5
t=1
t=0.5t=0.75
t=0.5t=0.625
t=0.5625
Interval Halving
Search through time for the point at which the objects collide You know when the objects were not penetrating (the last frame) You know when they are penetrating (this frame) So you have an upper and lower bound on the collision time
– Later than last frame, earlier than this frame
The aim is to do a series of tests to bring these bounds closer together
Each test checks for a collision at the midpoint of the current time interval– If there is a collision, the midpoint becomes the new upper bound– If not, the midpoint is the new lower bound
Keep going until the bounds are the same (or as accurate as desired)
Interval Halving Evaluation
Advantages:– Finds accurate collisions in time and space, which may be
essential– Not too expensive
Disadvantages:– Takes longer than a hack (but note that time is bounded, and
you get to control it)– May not work for fast moving objects and thin obstacles
• Why not?
Still, it is the method of choice for many applications
Collision Response
What happens if there is a collision?– A complex issue, no simple and uniform solutions. It is
game dependent.– Use game physics to find the answer in simple situations.– Example: in the game of pool, you can calculate the
bounces of balls using Newtonian physics (momentum and kinetic energy conservation).
Ray-Scene Intersection
Ray-Sphere Intersection
Ray-Sphere Intersection I
Ray-Sphere Intersection II
Ray-Sphere Intersection
Ray-Triangle Intersection
Ray-Plane Intersection
Ray-Triangle I Intersection
Ray-Triangle II Intersection
Other Ray-Primitive Intersections
Intersection Tests: How About Object-Object ?
Methods for: – Spheres– Oriented Boxes– Capsules– Lozenges– Cylinders– Ellipsoids– Triangles
But first let’s check some basic issues on collision/response…
Exploit coherency through witnessing
Collision Detection
Speed up with bounding boxes, grids, hierarchies, etc.
separating plane
Two convex objects are non-penetrating iff there exists aseparating plane between them
First find a separating plane andsee if it is still valid after the nextsimulation step
Collision Detection
Convex objects– Look for separating plane
• Test all faces
• Test each edge from obj 1 against vertex of obj 2
– Save separating plane for next animation frame
Collision Detection
Concave Objects– Break apart
– Convex hull• Automatic or artist-created
Collision Detection
To go faster– Sort on one dimension
• Bucket sort (i.e. discretize in 1 dimension)
– Exploit temporal coherence• Maintain a list of object pairs that are close to each
other• Use current speeds to estimate likely collisions
– Use cheaper tests
Collision Detection
Conditions for collision
Collision Detection
N
A
B
ba pp −
N
A
B
ba pp −N
A
Bba pp −
))()(()()()( ttttt aaaaa xpωvp −×+=
0))()(( >−⋅ tt ba ppN 0))()(( =−⋅ tt ba ppN 0))()(( <−⋅ tt ba ppN
separating contact colliding
Collision Response
Collision Response Sphere approaching a Plane
pn vvv +=
npv
nv v
nv−v′
pv
n)n .(vv =n
np vvv −=
np vvv −=′What kind of response?
Totally elastic!No kinetic energy is lost response is “perfectly bouncy”
“Perfectly Bouncy” Response
nv−v′
pvnp vvv −=′
Soft Body Collision
Collision
Force is applied to prevent interpenetration
Soft Body Collision
Collision
Apply forces and change the velocity
Harder Collision
Collision
Higher force over a shorter time
Rigid Body Collision
Collision
Impulsive force produces a discontinuous velocity
How to “Suggest” Sphere Deformation?
pn vvv +=
npv
nv v
nv−v′
pv
n)n .(vv =n
np vvv −=
np kvvv −=′
k, in [0,1] coefficient of restitution
Using Coefficient of Restitution:
As k gets smaller more and more energy is lost less and less bouncy
nv−
v′pv
np vvv 5.0−=′
Using Coefficient of Restitution:
As k gets smaller more and more energy is lost less and less bouncy
nv−
pvv =′
np vvv 0.0−=′
Case Study 1: Player-Wall Collisions
First person games must prevent the player from walking through walls and other obstacles
In the most general case, the player is a polygonal mesh and the walls are polygonal meshes
On each frame, the player moves along a path that is not known in advance– Assume it is piecewise linear – straight steps on each frame– Assume the player’s motion could be fast
Stupid Algorithm
On each step, do a general mesh-to-mesh intersection test to find out if the player intersects the wall
If they do, refuse to allow the player to move What is poor about this approach? In what ways can we
improve upon it?– In speed?– In accuracy?– In response?
Ways to Improve
Even the seemingly simple problem of determining if the player hit the wall reveals a wealth of techniques– Collision proxies
– Spatial data structures to localize
– Finding precise collision times
– Responding to collisions
Collision Proxies
General mesh-mesh intersections are expensive Proxy: Something that takes the place of the real object A collision proxy is a piece of geometry used to
represent a complex object for the purposes of finding a collision
If the proxy collides, the object is said to collide Collision points are mapped back onto the original object What makes a good proxy? What types of geometry are regularly used as proxies?
Proxy Properties
A good proxy is cheap to compute collisions for and a tight fit to the real geometry
Common proxies are spheres, cylinders or boxes of various forms, sometimes ellipsoids– What would we use for: A fat player, a thin player, a rocket, a
car …
Proxies exploit several facts about human perception:– We are extraordinarily bad at determining the correctness of a
collision between two complex objects– The more stuff is happening, and the faster it happens, the
more problems we have detecting errors– Players frequently cannot see themselves– We are bad a predicting what should happen in response to a
collision
Spatial Data Structures
You can only hit something that is close to you Spatial data structures can tell you what is close to an
object– Fixed grid, Octrees, Kd-trees, BSP trees, …
Recall in particular the algorithm for intersecting a sphere (or another primitive) with a BSP tree– Collision works just like view frustum culling, but now we are
intersecting more general geometry with the data structure
For the player-wall problem, typically you use the same spatial data structure that is used for rendering– BSP trees are the most common
Exploiting Coherence
The player normally doesn’t move far between frames
The cells they intersected the last time are probably the same cells they intersect now, or at least they are close
The aim is to track which cells the player is in without doing a full search each time
Easiest to exploit with a cell portal structure …
Cell-Portal Collisions
Keep track which cell/s the player is currently intersecting– Can have more than one if the player straddles a cell boundary– Always use a proxy (bounding volume) for tracking cells– Also keep track of which portals the player is straddling
The only way a player can enter a new cell is through a portal On each frame:
– Intersect the player with the current cell walls and contents (because they’re solid)
– Intersect the player with the portals– If the player intersects a portal, check that they are considered “in” the
neighbor cell– If the player no longer straddles a portal, they have just left a cell
What are the implicit assumptions?
Defining Penetration Depth
There is more than one way to define penetration depth
1. The distance to move back along the incoming path to avoid collision– But this may be difficult to compute
2. The minimum distance to move in any direction to avoid collision– Also difficult to compute in many cases
3. The distance in some particular direction– But what direction?– “Normal” to penetration surface
Managing Fast Moving Objects
Several ways to do it, with increasing costs Test a line segment representing the motion of the center of the
object– Pros: Works for large obstacles, cheap– Cons: May still miss collisions. How?
Conservative prediction: Only move objects as far as you can be sure to catch the collision– Pros: Will find all collisions– Cons: May be expensive, and need a way to know what the maximum
step is Space-time bounds: Bound the object in space and time, and check
the bound– Pros: Will find all collisions– Cons: Expensive, and have to be able to bound motion
Prediction and Bounds
Conservative motion:– Assume a maximum velocity and a smallest feature size– Largest conservative step is the smallest distance divided by the highest
speed - clearly could be very small– Other more complex metrics are possible
Bounding motion:– Assume linear motion– Find the radius of a bounding sphere– Build a box that will contain that sphere for the frame step– Also works for ballistic and some other predictable motions
Simple alternative: Just miss the hard cases - the player may not notice
Collision Response
For player motions, the best thing to do is generally move the player tangentially to the obstacle
Have to do this recursively to make sure that all collisions are caught– Find time and place of collision– Adjust velocity of player– Repeat with new velocity, start time an start position (reduced
time interval)
Ways to handle multiple contacts at the same time– Find a direction that is tangential to all contacts– How do you do this for two planes?
Game Physics