Collision Detection 1 - Temple University

Document Sample
Collision Detection 1 - Temple University Powered By Docstoc
					    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
polygons the objects are made
              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
• Bad fill efficiency
• 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:

     • Start with BV for each primitive
                   • 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