+ Winding
    + Clockwise
    + AntiClockwise
    + Undefined
    
+ GeomPoly
    + new ({Array<Vec2>,Vector<Vec2>,Vec2List,GeomPoly}=null)

    + push(Vec2) : Vec2
    + unshift(Vec2) : Vec2
    + pop() : Void
    + shift() : Void
    + erase(Int) : Void //can be negative
    + skip_forward(Int) : Void
    + skip_backwards(Int) : Void
    + current() : Vec2
    
    + isSimple() : Bool //O(n.log(n))
    + isMonotone() : Bool //y-monotone, O(n)
    + isConvex() : Bool //O(n)
    + isDegenerate() : Bool //O(n)

    // when polygon is not simple, result is not well-defined
    + winding() : Winding //O(n)
    + isClockwise() : Bool //O(n), same properties of winding()

    + area() : Float //O(n)
    
    + empty() : Bool //O(1)
    + size() : Int //O(n)

    + copy() : GeomPoly //O(n)... obviously

    // postcondition: empty()
    + clear() //O(n)

    // precondition: !isDegenerate()
    // postcondition: for each(output) output.isSimple()
    + simple_decomposition() : GeomPolyList // O((n+k).log(n)) where k is the number of self intersections

    // precondition: isSimple(), !isDegenerate()
    // postcondition: for each(output) output.isMonotone()
    + monotone_decomposition() : GeomPolyList // O(n.log(n))

    // precondition: isSimple(), !isDegenerate()
    // postcondition: for each(output) output.isConvex()
    + convex_decomposition() : GeomPolyList // O(n.log(n))

    + toArray() : Array<Vec2> //not important anymore.

~Debug
    + drawPolygon({Array<Vec2>,Vector<Vec2>,Vec2List,GeomPoly}, colour:Int)
    + drawFilledPolygon({Array<Vec2>,Vector<Vec2>,Vec2List,GeomPoly},colour:Int)

GeomPoly :: contains(position:Vec2) : Bool
GeomPoly :: iterator/forward_iterator/backwards_iterator : Iterator<Vec2>

MarchingSquares :: static run (iso:Float->Float->Float, bounds:AABB, cellsize:Vec2, ?quality:Int=2, ?subgrid:Vec2=null, ?combine:Bool=true) : GeomPolyList.

new Body(BodyType.DYNAMIC, Vec2.weak(x,y));

var v = Vec2.get(x,y);
new Body(BodyType.DYNAMIC, v);
v.dispose();

new Polygon(Polygon.box(w,h,true));

var vs = Polygon.box(w,h);
new Polygon(vs);
for(v in vs) v.dispose();

new InteractionListener(CbEvent.BEGIN, cb1,cb2, ?handler)

 Interactor->Interactor->Void 

new InteractionListener(CbEvent.END, cb1,cb2, ?handler)

new PreListener(cb1,cb2, handler)

Arbiter->PreFlag

//basic name change.
Shape::circle  => Shape::castCircle
Shape::polygon => Shape::castPolygon

//removal
Space::kinematics, Space::dynamics, Space::statics

Vec2::rotate(angle:Float):Vec2 rotating vector in place and returning 'this'

Body::rotate(centre:Vec2, angle:Float):Void rotating body about given point in world space

Compound::translate(translation:Vec2):Void, translate every body inside
Compound::rotate(centre:Vec2, angle:Float):Void, rotate every body inside about given point

Compound::visitBodies(lambda:Body->Void):Void, apply given function to all bodies contained at some level of the compound tree
Compound::visitConstraints(...)
Compound::visitCompounds(...)

+Space::sortContacts = true
+Space::userData : Dynamic
+Space::id : Int

body.graphic = ...;
body.graphicUpdate = function(b:Body) {
    b.graphic.x = b.position.x;
    b.graphic.y = b.position.y;
    b.graphic.rotation = (b.rotation*180/Math.PI)%360;
}

body.graphic = null; <-- doesn't matter, graphicUpdate takes precedence
body.graphicUpdate = function(b:Body) {
   //do some custom rendering without any display object or similar at all.
}

new InteractionListener(CbEvent.BEGIN, InteractionType.COLLISION, cb1, cb2, handler);
new PreListener(InteractionType.ANY, cb1, cb2, handler);

function(int1:Interactor,int2:Interactor):void { }

function(int1:Interactor,int2:Interactor,arbs:ArbiterList):void { }

- CallbackQueue
~ Space {
   - callbacks : CallbackQueue
}
+ BodyCallback extends Callback {
   + body : Body
}
+ ConstraintCallback extends Callback {
   + constraint : Constraint
}
+ InteractionCallback extends Callback {
   + int1 : Interactor
   + int2 : Interactor
   + arbiters : ArbiterList
}
+ PreCallback extends Callback {
   + int1 : Interactor
   + int2 : Interactor
   + arbiter : Arbiter
   + swapped : Bool
}
~ BodyListener {
   - ?handler:Body->Void
   +  handler:BodyCallback->Void //no longer optional, same change for constructor
}
~ ConstraintListener {
   - ?handler:Constraint->Void
   +  handler:ConstraintCallback->Void //no longer optional, same change for constructor
}
~ InteractionListener {
   - ?handler:Interactor->Interactor->ArbiterList->Void
   +  handler:InteractionCallback->Void //no longer optional, same change for constructor
}
~ PreListener {
   - handler:Arbiter->PreFlag
   + handler:PreCallback->PreFlag
}