docs: function checkGJK( bodyA, bodyB ){
  
          var scratch = Physics.scratchpad()
              ,d = scratch.vector()
              ,tmp = scratch.vector()
              ,os = scratch.vector()
              ,overlap
              ,result
              ,support
              ,inc
              ,collision = false
              ,aabbA = bodyA.aabb()
              ,dimA = Math.min( aabbA.hw, aabbA.hh )
              ,aabbB = bodyB.aabb()
              ,dimB = Math.min( aabbB.hw, aabbB.hh )
              ;
  
          // just check the overlap first
          support = getSupportFn( bodyA, bodyB );
          d.clone( bodyA.state.pos )
              .vadd( bodyA.getGlobalOffset( os ) )
              .vsub( bodyB.state.pos )
              .vsub( bodyB.getGlobalOffset( os ) )
              ;
          result = Physics.gjk(support, d, true);
  
          if ( result.overlap ){
  
              // there is a collision. let's do more work.
              collision = {
                  bodyA: bodyA,
                  bodyB: bodyB
              };
  
              // inc by 1% of the smallest dim.
              inc = 1e-2 * Math.min(dimA || 1, dimB || 1);
  
              // first get the min distance of between core objects
              support.useCore = true;
              support.marginA = 0;
              support.marginB = 0;
  
              // while there's still an overlap (or we don't have a positive distance)
              // and the support margins aren't bigger than the shapes...
              // search for the distance data
              while ( (result.overlap || result.distance === 0) && (support.marginA < dimA || support.marginB < dimB) ){
                  if ( support.marginA < dimA ){
                      support.marginA += inc;
                  }
                  if ( support.marginB < dimB ){
                      support.marginB += inc;
                  }
  
                  result = Physics.gjk(support, d);
              }
  
              if ( result.overlap || result.maxIterationsReached ){
                  // This implementation can't deal with a core overlap yet
                  return scratch.done(false);
              }
  
              // calc overlap
              overlap = (support.marginA + support.marginB) - result.distance;
  
              if ( overlap <= 0 ){
                  return scratch.done(false);
              }
  
              collision.overlap = overlap;
              // @TODO: for now, just let the normal be the mtv
              collision.norm = d.clone( result.closest.b ).vsub( tmp.clone( result.closest.a ) ).normalize().values();
              collision.mtv = d.mult( overlap ).values();
              // get a corresponding hull point for one of the core points.. relative to body A
              collision.pos = d.clone( collision.norm ).mult( support.marginA ).vadd( tmp.clone( result.closest.a ) ).vsub( bodyA.state.pos ).values();
          }
  
          return scratch.done( collision );
      }