# This file was automatically generated by SWIG (http://www.swig.org).
# Version 1.3.34
#
# Don't modify this file, modify the SWIG interface instead.

import _Box2D2
import new
new_instancemethod = new.instancemethod
try:
    _swig_property = property
except NameError:
    pass # Python < 2.2 doesn't have 'property'.
def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
    if (name == "thisown"): return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'PySwigObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name,None)
    if method: return method(self,value)
    if (not static) or hasattr(self,name):
        self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)

def _swig_setattr(self,class_type,name,value):
    return _swig_setattr_nondynamic(self,class_type,name,value,0)

def _swig_getattr(self,class_type,name):
    if (name == "thisown"): return self.this.own()
    method = class_type.__swig_getmethods__.get(name,None)
    if method: return method(self)
    raise AttributeError,name

def _swig_repr(self):
    try: strthis = "proxy of " + self.this.__repr__()
    except: strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)

import types
try:
    _object = types.ObjectType
    _newclass = 1
except AttributeError:
    class _object : pass
    _newclass = 0
del types


def _swig_setattr_nondynamic_method(set):
    def set_attr(self,name,value):
        if (name == "thisown"): return self.this.own(value)
        if hasattr(self,name) or (name == "this"):
            set(self,name,value)
        else:
            raise AttributeError("You cannot add attributes to %s" % self)
    return set_attr


try:
    import weakref
    weakref_proxy = weakref.proxy
except:
    weakref_proxy = lambda x: x



def b2Alloc(*args):
  """b2Alloc(int32 size) -> void"""
  return _Box2D2.b2Alloc(*args)

def b2Free(*args):
  """b2Free(void mem)"""
  return _Box2D2.b2Free(*args)
class b2Version(object):
    """Proxy of C++ b2Version class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    major = _swig_property(_Box2D2.b2Version_major_get, _Box2D2.b2Version_major_set)
    minor = _swig_property(_Box2D2.b2Version_minor_get, _Box2D2.b2Version_minor_set)
    revision = _swig_property(_Box2D2.b2Version_revision_get, _Box2D2.b2Version_revision_set)
    def __init__(self, *args): 
        """__init__(self) -> b2Version"""
        _Box2D2.b2Version_swiginit(self,_Box2D2.new_b2Version(*args))
    __swig_destroy__ = _Box2D2.delete_b2Version
b2Version_swigregister = _Box2D2.b2Version_swigregister
b2Version_swigregister(b2Version)
cvar = _Box2D2.cvar
b2_pi = cvar.b2_pi
b2_maxManifoldPoints = cvar.b2_maxManifoldPoints
b2_maxPolygonVertices = cvar.b2_maxPolygonVertices
b2_maxProxies = cvar.b2_maxProxies
b2_maxPairs = cvar.b2_maxPairs
b2_linearSlop = cvar.b2_linearSlop
b2_angularSlop = cvar.b2_angularSlop
b2_toiSlop = cvar.b2_toiSlop
b2_maxTOIContactsPerIsland = cvar.b2_maxTOIContactsPerIsland
b2_velocityThreshold = cvar.b2_velocityThreshold
b2_maxLinearCorrection = cvar.b2_maxLinearCorrection
b2_maxAngularCorrection = cvar.b2_maxAngularCorrection
b2_maxLinearVelocity = cvar.b2_maxLinearVelocity
b2_maxLinearVelocitySquared = cvar.b2_maxLinearVelocitySquared
b2_maxAngularVelocity = cvar.b2_maxAngularVelocity
b2_maxAngularVelocitySquared = cvar.b2_maxAngularVelocitySquared
b2_contactBaumgarte = cvar.b2_contactBaumgarte
b2_timeToSleep = cvar.b2_timeToSleep
b2_linearSleepTolerance = cvar.b2_linearSleepTolerance
b2_angularSleepTolerance = cvar.b2_angularSleepTolerance


def b2MixFriction(*args):
  """b2MixFriction(float32 friction1, float32 friction2) -> float32"""
  return _Box2D2.b2MixFriction(*args)

def b2MixRestitution(*args):
  """b2MixRestitution(float32 restitution1, float32 restitution2) -> float32"""
  return _Box2D2.b2MixRestitution(*args)

def b2IsValid(*args):
  """b2IsValid(float32 x) -> bool"""
  return _Box2D2.b2IsValid(*args)

def b2InvSqrt(*args):
  """b2InvSqrt(float32 x) -> float32"""
  return _Box2D2.b2InvSqrt(*args)
class b2Vec2(object):
    """Proxy of C++ b2Vec2 class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> b2Vec2
        __init__(self, float32 x, float32 y) -> b2Vec2
        """
        _Box2D2.b2Vec2_swiginit(self,_Box2D2.new_b2Vec2(*args))
    def SetZero(*args):
        """SetZero(self)"""
        return _Box2D2.b2Vec2_SetZero(*args)

    def Set(*args):
        """Set(self, float32 x_, float32 y_)"""
        return _Box2D2.b2Vec2_Set(*args)

    def __neg__(*args):
        """__neg__(self) -> b2Vec2"""
        return _Box2D2.b2Vec2___neg__(*args)

    def add_vector(*args):
        """add_vector(self, b2Vec2 v)"""
        return _Box2D2.b2Vec2_add_vector(*args)

    def sub_vector(*args):
        """sub_vector(self, b2Vec2 v)"""
        return _Box2D2.b2Vec2_sub_vector(*args)

    def mul_float(*args):
        """mul_float(self, float32 a)"""
        return _Box2D2.b2Vec2_mul_float(*args)

    def Length(*args):
        """Length(self) -> float32"""
        return _Box2D2.b2Vec2_Length(*args)

    def LengthSquared(*args):
        """LengthSquared(self) -> float32"""
        return _Box2D2.b2Vec2_LengthSquared(*args)

    def Normalize(*args):
        """Normalize(self) -> float32"""
        return _Box2D2.b2Vec2_Normalize(*args)

    def IsValid(*args):
        """IsValid(self) -> bool"""
        return _Box2D2.b2Vec2_IsValid(*args)

    x = _swig_property(_Box2D2.b2Vec2_x_get, _Box2D2.b2Vec2_x_set)
    y = _swig_property(_Box2D2.b2Vec2_y_get, _Box2D2.b2Vec2_y_set)
    def __repr__(self):
        return "b2Vec2(%g,%g)" % (self.x, self.y)
    def tuple(self):
        return (self.x, self.y)
    def fromTuple(self, tuple):
        self.x, self.y = tuple
        return self
    def copy(self):
        return b2Vec2(self.x, self.y)
    def __iadd__(self, other):
        self.add_vector(other)
        return self
    def __isub__(self, other):
        self.sub_vector(other)
        return self
    def __imul__(self, a):
        self.mul_float(a)
        return self
    def __idiv__(self, a):
        self.div_float(a)
        return self


    def __div__(*args):
        """__div__(self, float32 a) -> b2Vec2"""
        return _Box2D2.b2Vec2___div__(*args)

    def __mul__(*args):
        """__mul__(self, float32 a) -> b2Vec2"""
        return _Box2D2.b2Vec2___mul__(*args)

    def __add__(*args):
        """__add__(self, b2Vec2 other) -> b2Vec2"""
        return _Box2D2.b2Vec2___add__(*args)

    def __sub__(*args):
        """__sub__(self, b2Vec2 other) -> b2Vec2"""
        return _Box2D2.b2Vec2___sub__(*args)

    def __rmul__(*args):
        """__rmul__(self, float32 a) -> b2Vec2"""
        return _Box2D2.b2Vec2___rmul__(*args)

    def __rdiv__(*args):
        """__rdiv__(self, float32 a) -> b2Vec2"""
        return _Box2D2.b2Vec2___rdiv__(*args)

    def div_float(*args):
        """div_float(self, float32 a)"""
        return _Box2D2.b2Vec2_div_float(*args)

    __swig_destroy__ = _Box2D2.delete_b2Vec2
b2Vec2.SetZero = new_instancemethod(_Box2D2.b2Vec2_SetZero,None,b2Vec2)
b2Vec2.Set = new_instancemethod(_Box2D2.b2Vec2_Set,None,b2Vec2)
b2Vec2.__neg__ = new_instancemethod(_Box2D2.b2Vec2___neg__,None,b2Vec2)
b2Vec2.add_vector = new_instancemethod(_Box2D2.b2Vec2_add_vector,None,b2Vec2)
b2Vec2.sub_vector = new_instancemethod(_Box2D2.b2Vec2_sub_vector,None,b2Vec2)
b2Vec2.mul_float = new_instancemethod(_Box2D2.b2Vec2_mul_float,None,b2Vec2)
b2Vec2.Length = new_instancemethod(_Box2D2.b2Vec2_Length,None,b2Vec2)
b2Vec2.LengthSquared = new_instancemethod(_Box2D2.b2Vec2_LengthSquared,None,b2Vec2)
b2Vec2.Normalize = new_instancemethod(_Box2D2.b2Vec2_Normalize,None,b2Vec2)
b2Vec2.IsValid = new_instancemethod(_Box2D2.b2Vec2_IsValid,None,b2Vec2)
b2Vec2.__div__ = new_instancemethod(_Box2D2.b2Vec2___div__,None,b2Vec2)
b2Vec2.__mul__ = new_instancemethod(_Box2D2.b2Vec2___mul__,None,b2Vec2)
b2Vec2.__add__ = new_instancemethod(_Box2D2.b2Vec2___add__,None,b2Vec2)
b2Vec2.__sub__ = new_instancemethod(_Box2D2.b2Vec2___sub__,None,b2Vec2)
b2Vec2.__rmul__ = new_instancemethod(_Box2D2.b2Vec2___rmul__,None,b2Vec2)
b2Vec2.__rdiv__ = new_instancemethod(_Box2D2.b2Vec2___rdiv__,None,b2Vec2)
b2Vec2.div_float = new_instancemethod(_Box2D2.b2Vec2_div_float,None,b2Vec2)
b2Vec2_swigregister = _Box2D2.b2Vec2_swigregister
b2Vec2_swigregister(b2Vec2)

class b2Mat22(object):
    """Proxy of C++ b2Mat22 class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> b2Mat22
        __init__(self, b2Vec2 c1, b2Vec2 c2) -> b2Mat22
        __init__(self, float32 a11, float32 a12, float32 a21, float32 a22) -> b2Mat22
        __init__(self, float32 angle) -> b2Mat22
        """
        _Box2D2.b2Mat22_swiginit(self,_Box2D2.new_b2Mat22(*args))
    def Set(*args):
        """
        Set(self, b2Vec2 c1, b2Vec2 c2)
        Set(self, float32 angle)
        """
        return _Box2D2.b2Mat22_Set(*args)

    def SetIdentity(*args):
        """SetIdentity(self)"""
        return _Box2D2.b2Mat22_SetIdentity(*args)

    def SetZero(*args):
        """SetZero(self)"""
        return _Box2D2.b2Mat22_SetZero(*args)

    def GetAngle(*args):
        """GetAngle(self) -> float32"""
        return _Box2D2.b2Mat22_GetAngle(*args)

    def Invert(*args):
        """Invert(self) -> b2Mat22"""
        return _Box2D2.b2Mat22_Invert(*args)

    def Solve(*args):
        """Solve(self, b2Vec2 b) -> b2Vec2"""
        return _Box2D2.b2Mat22_Solve(*args)

    col1 = _swig_property(_Box2D2.b2Mat22_col1_get, _Box2D2.b2Mat22_col1_set)
    col2 = _swig_property(_Box2D2.b2Mat22_col2_get, _Box2D2.b2Mat22_col2_set)
    def __repr__(self):
        return "b2Mat22(col1: %s col2: %s)" % (self.col1, self.col2)

    __swig_destroy__ = _Box2D2.delete_b2Mat22
b2Mat22.Set = new_instancemethod(_Box2D2.b2Mat22_Set,None,b2Mat22)
b2Mat22.SetIdentity = new_instancemethod(_Box2D2.b2Mat22_SetIdentity,None,b2Mat22)
b2Mat22.SetZero = new_instancemethod(_Box2D2.b2Mat22_SetZero,None,b2Mat22)
b2Mat22.GetAngle = new_instancemethod(_Box2D2.b2Mat22_GetAngle,None,b2Mat22)
b2Mat22.Invert = new_instancemethod(_Box2D2.b2Mat22_Invert,None,b2Mat22)
b2Mat22.Solve = new_instancemethod(_Box2D2.b2Mat22_Solve,None,b2Mat22)
b2Mat22_swigregister = _Box2D2.b2Mat22_swigregister
b2Mat22_swigregister(b2Mat22)

class b2XForm(object):
    """Proxy of C++ b2XForm class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> b2XForm
        __init__(self, b2Vec2 position, b2Mat22 R) -> b2XForm
        """
        _Box2D2.b2XForm_swiginit(self,_Box2D2.new_b2XForm(*args))
    def SetIdentity(*args):
        """SetIdentity(self)"""
        return _Box2D2.b2XForm_SetIdentity(*args)

    position = _swig_property(_Box2D2.b2XForm_position_get, _Box2D2.b2XForm_position_set)
    R = _swig_property(_Box2D2.b2XForm_R_get, _Box2D2.b2XForm_R_set)
    __swig_destroy__ = _Box2D2.delete_b2XForm
b2XForm.SetIdentity = new_instancemethod(_Box2D2.b2XForm_SetIdentity,None,b2XForm)
b2XForm_swigregister = _Box2D2.b2XForm_swigregister
b2XForm_swigregister(b2XForm)

class b2Sweep(object):
    """Proxy of C++ b2Sweep class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def GetXForm(*args):
        """GetXForm(self, b2XForm xf, float32 t)"""
        return _Box2D2.b2Sweep_GetXForm(*args)

    def Advance(*args):
        """Advance(self, float32 t)"""
        return _Box2D2.b2Sweep_Advance(*args)

    localCenter = _swig_property(_Box2D2.b2Sweep_localCenter_get, _Box2D2.b2Sweep_localCenter_set)
    c0 = _swig_property(_Box2D2.b2Sweep_c0_get, _Box2D2.b2Sweep_c0_set)
    c = _swig_property(_Box2D2.b2Sweep_c_get, _Box2D2.b2Sweep_c_set)
    a0 = _swig_property(_Box2D2.b2Sweep_a0_get, _Box2D2.b2Sweep_a0_set)
    a = _swig_property(_Box2D2.b2Sweep_a_get, _Box2D2.b2Sweep_a_set)
    t0 = _swig_property(_Box2D2.b2Sweep_t0_get, _Box2D2.b2Sweep_t0_set)
    def __init__(self, *args): 
        """__init__(self) -> b2Sweep"""
        _Box2D2.b2Sweep_swiginit(self,_Box2D2.new_b2Sweep(*args))
    __swig_destroy__ = _Box2D2.delete_b2Sweep
b2Sweep.GetXForm = new_instancemethod(_Box2D2.b2Sweep_GetXForm,None,b2Sweep)
b2Sweep.Advance = new_instancemethod(_Box2D2.b2Sweep_Advance,None,b2Sweep)
b2Sweep_swigregister = _Box2D2.b2Sweep_swigregister
b2Sweep_swigregister(b2Sweep)


def b2Dot(*args):
  """b2Dot(b2Vec2 a, b2Vec2 b) -> float32"""
  return _Box2D2.b2Dot(*args)

def b2sub(*args):
  """b2sub(b2Vec2 a, b2Vec2 b) -> b2Vec2"""
  return _Box2D2.b2sub(*args)

def b2mul(*args):
  """b2mul(float32 s, b2Vec2 a) -> b2Vec2"""
  return _Box2D2.b2mul(*args)

def b2equ(*args):
  """b2equ(b2Vec2 a, b2Vec2 b) -> bool"""
  return _Box2D2.b2equ(*args)

def b2DistanceSquared(*args):
  """b2DistanceSquared(b2Vec2 a, b2Vec2 b) -> float32"""
  return _Box2D2.b2DistanceSquared(*args)

def b2Min(*args):
  """b2Min(b2Vec2 a, b2Vec2 b) -> b2Vec2"""
  return _Box2D2.b2Min(*args)

def b2Max(*args):
  """b2Max(b2Vec2 a, b2Vec2 b) -> b2Vec2"""
  return _Box2D2.b2Max(*args)

def b2Clamp(*args):
  """b2Clamp(b2Vec2 a, b2Vec2 low, b2Vec2 high) -> b2Vec2"""
  return _Box2D2.b2Clamp(*args)
RAND_LIMIT = _Box2D2.RAND_LIMIT

def b2NextPowerOfTwo(*args):
  """b2NextPowerOfTwo(uint32 x) -> uint32"""
  return _Box2D2.b2NextPowerOfTwo(*args)

def b2IsPowerOfTwo(*args):
  """b2IsPowerOfTwo(uint32 x) -> bool"""
  return _Box2D2.b2IsPowerOfTwo(*args)
class b2ContactID(object):
    """Proxy of C++ b2ContactID class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    key = _swig_property(_Box2D2.b2ContactID_key_get, _Box2D2.b2ContactID_key_set)
    features = _swig_property(_Box2D2.b2ContactID_features_get)
    def __repr__(self):
        return "b2ContactID(key: %d Features: \n\t%s)" % \
            (self.key, self.features)

    def __init__(self, *args): 
        """__init__(self) -> b2ContactID"""
        _Box2D2.b2ContactID_swiginit(self,_Box2D2.new_b2ContactID(*args))
    __swig_destroy__ = _Box2D2.delete_b2ContactID
b2ContactID_swigregister = _Box2D2.b2ContactID_swigregister
b2ContactID_swigregister(b2ContactID)
b2Vec2_zero = cvar.b2Vec2_zero
b2Mat22_identity = cvar.b2Mat22_identity
b2XForm_identity = cvar.b2XForm_identity

def b2Cross(*args):
  """
    b2Cross(b2Vec2 a, b2Vec2 b) -> float32
    b2Cross(b2Vec2 a, float32 s) -> b2Vec2
    b2Cross(float32 s, b2Vec2 a) -> b2Vec2
    """
  return _Box2D2.b2Cross(*args)

def b2add(*args):
  """
    b2add(b2Vec2 a, b2Vec2 b) -> b2Vec2
    b2add(b2Mat22 A, b2Mat22 B) -> b2Mat22
    """
  return _Box2D2.b2add(*args)

def b2Mul(*args):
  """
    b2Mul(b2Mat22 A, b2Vec2 v) -> b2Vec2
    b2Mul(b2Mat22 A, b2Mat22 B) -> b2Mat22
    b2Mul(b2XForm T, b2Vec2 v) -> b2Vec2
    """
  return _Box2D2.b2Mul(*args)

def b2MulT(*args):
  """
    b2MulT(b2Mat22 A, b2Vec2 v) -> b2Vec2
    b2MulT(b2Mat22 A, b2Mat22 B) -> b2Mat22
    b2MulT(b2XForm T, b2Vec2 v) -> b2Vec2
    """
  return _Box2D2.b2MulT(*args)

def b2Abs(*args):
  """
    b2Abs(float32 a) -> float32
    b2Abs(b2Vec2 a) -> b2Vec2
    b2Abs(b2Mat22 A) -> b2Mat22
    """
  return _Box2D2.b2Abs(*args)

def b2Random(*args):
  """
    b2Random() -> float32
    b2Random(float32 lo, float32 hi) -> float32
    """
  return _Box2D2.b2Random(*args)
b2_nullFeature = cvar.b2_nullFeature

class b2ContactID_features(object):
    """Proxy of C++ b2ContactID_features class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    referenceEdge = _swig_property(_Box2D2.b2ContactID_features_referenceEdge_get, _Box2D2.b2ContactID_features_referenceEdge_set)
    incidentEdge = _swig_property(_Box2D2.b2ContactID_features_incidentEdge_get, _Box2D2.b2ContactID_features_incidentEdge_set)
    incidentVertex = _swig_property(_Box2D2.b2ContactID_features_incidentVertex_get, _Box2D2.b2ContactID_features_incidentVertex_set)
    flip = _swig_property(_Box2D2.b2ContactID_features_flip_get, _Box2D2.b2ContactID_features_flip_set)
    def __repr__(self):
        return "b2ContactID::Features(\n\treferenceFace: %d incidentEdge: %d incidentVertex: %d flip: %d)" % \
            (self.referenceFace, self.incidentEdge, self.incidentVertex, self.flip)

    def __init__(self, *args): 
        """__init__(self) -> b2ContactID_features"""
        _Box2D2.b2ContactID_features_swiginit(self,_Box2D2.new_b2ContactID_features(*args))
    __swig_destroy__ = _Box2D2.delete_b2ContactID_features
b2ContactID_features_swigregister = _Box2D2.b2ContactID_features_swigregister
b2ContactID_features_swigregister(b2ContactID_features)

class b2ManifoldPoint(object):
    """Proxy of C++ b2ManifoldPoint class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    localPoint1 = _swig_property(_Box2D2.b2ManifoldPoint_localPoint1_get, _Box2D2.b2ManifoldPoint_localPoint1_set)
    localPoint2 = _swig_property(_Box2D2.b2ManifoldPoint_localPoint2_get, _Box2D2.b2ManifoldPoint_localPoint2_set)
    separation = _swig_property(_Box2D2.b2ManifoldPoint_separation_get, _Box2D2.b2ManifoldPoint_separation_set)
    normalImpulse = _swig_property(_Box2D2.b2ManifoldPoint_normalImpulse_get, _Box2D2.b2ManifoldPoint_normalImpulse_set)
    tangentImpulse = _swig_property(_Box2D2.b2ManifoldPoint_tangentImpulse_get, _Box2D2.b2ManifoldPoint_tangentImpulse_set)
    id = _swig_property(_Box2D2.b2ManifoldPoint_id_get, _Box2D2.b2ManifoldPoint_id_set)
    def __init__(self, *args): 
        """__init__(self) -> b2ManifoldPoint"""
        _Box2D2.b2ManifoldPoint_swiginit(self,_Box2D2.new_b2ManifoldPoint(*args))
    __swig_destroy__ = _Box2D2.delete_b2ManifoldPoint
b2ManifoldPoint_swigregister = _Box2D2.b2ManifoldPoint_swigregister
b2ManifoldPoint_swigregister(b2ManifoldPoint)

class b2Manifold(object):
    """Proxy of C++ b2Manifold class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    points = _swig_property(_Box2D2.b2Manifold_points_get, _Box2D2.b2Manifold_points_set)
    normal = _swig_property(_Box2D2.b2Manifold_normal_get, _Box2D2.b2Manifold_normal_set)
    pointCount = _swig_property(_Box2D2.b2Manifold_pointCount_get, _Box2D2.b2Manifold_pointCount_set)
    def __init__(self, *args): 
        """__init__(self) -> b2Manifold"""
        _Box2D2.b2Manifold_swiginit(self,_Box2D2.new_b2Manifold(*args))
    __swig_destroy__ = _Box2D2.delete_b2Manifold
b2Manifold_swigregister = _Box2D2.b2Manifold_swigregister
b2Manifold_swigregister(b2Manifold)

class b2Segment(object):
    """Proxy of C++ b2Segment class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def TestSegment(*args):
        """TestSegment(self, float32 lambda, b2Vec2 normal, b2Segment segment, float32 maxLambda) -> bool"""
        return _Box2D2.b2Segment_TestSegment(*args)

    p1 = _swig_property(_Box2D2.b2Segment_p1_get, _Box2D2.b2Segment_p1_set)
    p2 = _swig_property(_Box2D2.b2Segment_p2_get, _Box2D2.b2Segment_p2_set)
    def __init__(self, *args): 
        """__init__(self) -> b2Segment"""
        _Box2D2.b2Segment_swiginit(self,_Box2D2.new_b2Segment(*args))
    __swig_destroy__ = _Box2D2.delete_b2Segment
b2Segment.TestSegment = new_instancemethod(_Box2D2.b2Segment_TestSegment,None,b2Segment)
b2Segment_swigregister = _Box2D2.b2Segment_swigregister
b2Segment_swigregister(b2Segment)

class b2AABB(object):
    """Proxy of C++ b2AABB class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def IsValid(*args):
        """IsValid(self) -> bool"""
        return _Box2D2.b2AABB_IsValid(*args)

    lowerBound = _swig_property(_Box2D2.b2AABB_lowerBound_get, _Box2D2.b2AABB_lowerBound_set)
    upperBound = _swig_property(_Box2D2.b2AABB_upperBound_get, _Box2D2.b2AABB_upperBound_set)
    def __init__(self, *args): 
        """__init__(self) -> b2AABB"""
        _Box2D2.b2AABB_swiginit(self,_Box2D2.new_b2AABB(*args))
    __swig_destroy__ = _Box2D2.delete_b2AABB
b2AABB.IsValid = new_instancemethod(_Box2D2.b2AABB_IsValid,None,b2AABB)
b2AABB_swigregister = _Box2D2.b2AABB_swigregister
b2AABB_swigregister(b2AABB)

class b2OBB(object):
    """Proxy of C++ b2OBB class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    R = _swig_property(_Box2D2.b2OBB_R_get, _Box2D2.b2OBB_R_set)
    center = _swig_property(_Box2D2.b2OBB_center_get, _Box2D2.b2OBB_center_set)
    extents = _swig_property(_Box2D2.b2OBB_extents_get, _Box2D2.b2OBB_extents_set)
    def __init__(self, *args): 
        """__init__(self) -> b2OBB"""
        _Box2D2.b2OBB_swiginit(self,_Box2D2.new_b2OBB(*args))
    __swig_destroy__ = _Box2D2.delete_b2OBB
b2OBB_swigregister = _Box2D2.b2OBB_swigregister
b2OBB_swigregister(b2OBB)


def b2CollideCircles(*args):
  """
    b2CollideCircles(b2Manifold manifold, b2CircleShape circle1, b2XForm xf1, 
        b2CircleShape circle2, b2XForm xf2)
    """
  return _Box2D2.b2CollideCircles(*args)

def b2CollidePolygonAndCircle(*args):
  """
    b2CollidePolygonAndCircle(b2Manifold manifold, b2PolygonShape polygon, b2XForm xf1, 
        b2CircleShape circle, b2XForm xf2)
    """
  return _Box2D2.b2CollidePolygonAndCircle(*args)

def b2CollidePolygons(*args):
  """
    b2CollidePolygons(b2Manifold manifold, b2PolygonShape polygon1, b2XForm xf1, 
        b2PolygonShape polygon2, b2XForm xf2)
    """
  return _Box2D2.b2CollidePolygons(*args)

def b2TimeOfImpact(*args):
  """b2TimeOfImpact(b2Shape shape1, b2Sweep sweep1, b2Shape shape2, b2Sweep sweep2) -> float32"""
  return _Box2D2.b2TimeOfImpact(*args)

def b2TestOverlap(*args):
  """b2TestOverlap(b2AABB a, b2AABB b) -> bool"""
  return _Box2D2.b2TestOverlap(*args)
class b2MassData(object):
    """Proxy of C++ b2MassData class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    mass = _swig_property(_Box2D2.b2MassData_mass_get, _Box2D2.b2MassData_mass_set)
    center = _swig_property(_Box2D2.b2MassData_center_get, _Box2D2.b2MassData_center_set)
    I = _swig_property(_Box2D2.b2MassData_I_get, _Box2D2.b2MassData_I_set)
    def __init__(self, *args): 
        """__init__(self) -> b2MassData"""
        _Box2D2.b2MassData_swiginit(self,_Box2D2.new_b2MassData(*args))
    __swig_destroy__ = _Box2D2.delete_b2MassData
b2MassData_swigregister = _Box2D2.b2MassData_swigregister
b2MassData_swigregister(b2MassData)

def b2Distance(*args):
  """
    b2Distance(b2Vec2 a, b2Vec2 b) -> float32
    b2Distance(b2Vec2 x1, b2Vec2 x2, b2Shape shape1, b2XForm xf1, 
        b2Shape shape2, b2XForm xf2) -> float32
    """
  return _Box2D2.b2Distance(*args)

class b2FilterData(object):
    """Proxy of C++ b2FilterData class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    categoryBits = _swig_property(_Box2D2.b2FilterData_categoryBits_get, _Box2D2.b2FilterData_categoryBits_set)
    maskBits = _swig_property(_Box2D2.b2FilterData_maskBits_get, _Box2D2.b2FilterData_maskBits_set)
    groupIndex = _swig_property(_Box2D2.b2FilterData_groupIndex_get, _Box2D2.b2FilterData_groupIndex_set)
    def __init__(self, *args): 
        """__init__(self) -> b2FilterData"""
        _Box2D2.b2FilterData_swiginit(self,_Box2D2.new_b2FilterData(*args))
    __swig_destroy__ = _Box2D2.delete_b2FilterData
b2FilterData_swigregister = _Box2D2.b2FilterData_swigregister
b2FilterData_swigregister(b2FilterData)

e_unknownShape = _Box2D2.e_unknownShape
e_circleShape = _Box2D2.e_circleShape
e_polygonShape = _Box2D2.e_polygonShape
e_shapeTypeCount = _Box2D2.e_shapeTypeCount
class b2ShapeDef(object):
    """Proxy of C++ b2ShapeDef class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self) -> b2ShapeDef"""
        _Box2D2.b2ShapeDef_swiginit(self,_Box2D2.new_b2ShapeDef(*args))
    __swig_destroy__ = _Box2D2.delete_b2ShapeDef
    type = _swig_property(_Box2D2.b2ShapeDef_type_get, _Box2D2.b2ShapeDef_type_set)
    userData = _swig_property(_Box2D2.b2ShapeDef_userData_get, _Box2D2.b2ShapeDef_userData_set)
    friction = _swig_property(_Box2D2.b2ShapeDef_friction_get, _Box2D2.b2ShapeDef_friction_set)
    restitution = _swig_property(_Box2D2.b2ShapeDef_restitution_get, _Box2D2.b2ShapeDef_restitution_set)
    density = _swig_property(_Box2D2.b2ShapeDef_density_get, _Box2D2.b2ShapeDef_density_set)
    isSensor = _swig_property(_Box2D2.b2ShapeDef_isSensor_get, _Box2D2.b2ShapeDef_isSensor_set)
    filter = _swig_property(_Box2D2.b2ShapeDef_filter_get, _Box2D2.b2ShapeDef_filter_set)
b2ShapeDef_swigregister = _Box2D2.b2ShapeDef_swigregister
b2ShapeDef_swigregister(b2ShapeDef)

class b2Shape(object):
    """Proxy of C++ b2Shape class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    def GetType(*args):
        """GetType(self) -> b2ShapeType"""
        return _Box2D2.b2Shape_GetType(*args)

    def IsSensor(*args):
        """IsSensor(self) -> bool"""
        return _Box2D2.b2Shape_IsSensor(*args)

    def SetFilterData(*args):
        """SetFilterData(self, b2FilterData filter)"""
        return _Box2D2.b2Shape_SetFilterData(*args)

    def GetFilterData(*args):
        """GetFilterData(self) -> b2FilterData"""
        return _Box2D2.b2Shape_GetFilterData(*args)

    def GetBody(*args):
        """GetBody(self) -> b2Body"""
        return _Box2D2.b2Shape_GetBody(*args)

    def GetNext(*args):
        """GetNext(self) -> b2Shape"""
        return _Box2D2.b2Shape_GetNext(*args)

    def GetUserData(self): # override the C++ version as it does not work. 
        """Get the specified userData (m_userData)"""
        return self.pyGetUserData()


    def SetUserData(*args):
        """SetUserData(self, void data)"""
        return _Box2D2.b2Shape_SetUserData(*args)

    def TestPoint(*args):
        """TestPoint(self, b2XForm xf, b2Vec2 p) -> bool"""
        return _Box2D2.b2Shape_TestPoint(*args)

    def TestSegment(*args):
        """
        TestSegment(self, b2XForm xf, float32 lambda, b2Vec2 normal, b2Segment segment, 
            float32 maxLambda) -> bool
        """
        return _Box2D2.b2Shape_TestSegment(*args)

    def ComputeAABB(*args):
        """ComputeAABB(self, b2AABB aabb, b2XForm xf)"""
        return _Box2D2.b2Shape_ComputeAABB(*args)

    def ComputeSweptAABB(*args):
        """ComputeSweptAABB(self, b2AABB aabb, b2XForm xf1, b2XForm xf2)"""
        return _Box2D2.b2Shape_ComputeSweptAABB(*args)

    def ComputeMass(*args):
        """ComputeMass(self, b2MassData massData)"""
        return _Box2D2.b2Shape_ComputeMass(*args)

    def GetSweepRadius(*args):
        """GetSweepRadius(self) -> float32"""
        return _Box2D2.b2Shape_GetSweepRadius(*args)

    def GetFriction(*args):
        """GetFriction(self) -> float32"""
        return _Box2D2.b2Shape_GetFriction(*args)

    def GetRestitution(*args):
        """GetRestitution(self) -> float32"""
        return _Box2D2.b2Shape_GetRestitution(*args)

    def __repr__(self):
        return "b2Shape(from Body %s )" % (self.GetBody())
    def typeName(self):
        types = {  e_unknownShape   : "Unknown",
                    e_circleShape   : "Circle",
                    e_polygonShape  : "Polygon",
                    e_shapeTypeCount: "ShapeType" }
        return types[self.GetType()]
    def getAsType(self):
        """Return a typecasted version of the shape"""
        return (getattr(self, "as%s" % self.typeName())) ()

    def asCircle(*args):
        """asCircle(self) -> b2CircleShape"""
        return _Box2D2.b2Shape_asCircle(*args)

    def asPolygon(*args):
        """asPolygon(self) -> b2PolygonShape"""
        return _Box2D2.b2Shape_asPolygon(*args)

    def pyGetUserData(*args):
        """pyGetUserData(self) -> PyObject"""
        return _Box2D2.b2Shape_pyGetUserData(*args)

b2Shape.GetType = new_instancemethod(_Box2D2.b2Shape_GetType,None,b2Shape)
b2Shape.IsSensor = new_instancemethod(_Box2D2.b2Shape_IsSensor,None,b2Shape)
b2Shape.SetFilterData = new_instancemethod(_Box2D2.b2Shape_SetFilterData,None,b2Shape)
b2Shape.GetFilterData = new_instancemethod(_Box2D2.b2Shape_GetFilterData,None,b2Shape)
b2Shape.GetBody = new_instancemethod(_Box2D2.b2Shape_GetBody,None,b2Shape)
b2Shape.GetNext = new_instancemethod(_Box2D2.b2Shape_GetNext,None,b2Shape)
b2Shape.SetUserData = new_instancemethod(_Box2D2.b2Shape_SetUserData,None,b2Shape)
b2Shape.TestPoint = new_instancemethod(_Box2D2.b2Shape_TestPoint,None,b2Shape)
b2Shape.TestSegment = new_instancemethod(_Box2D2.b2Shape_TestSegment,None,b2Shape)
b2Shape.ComputeAABB = new_instancemethod(_Box2D2.b2Shape_ComputeAABB,None,b2Shape)
b2Shape.ComputeSweptAABB = new_instancemethod(_Box2D2.b2Shape_ComputeSweptAABB,None,b2Shape)
b2Shape.ComputeMass = new_instancemethod(_Box2D2.b2Shape_ComputeMass,None,b2Shape)
b2Shape.GetSweepRadius = new_instancemethod(_Box2D2.b2Shape_GetSweepRadius,None,b2Shape)
b2Shape.GetFriction = new_instancemethod(_Box2D2.b2Shape_GetFriction,None,b2Shape)
b2Shape.GetRestitution = new_instancemethod(_Box2D2.b2Shape_GetRestitution,None,b2Shape)
b2Shape.asCircle = new_instancemethod(_Box2D2.b2Shape_asCircle,None,b2Shape)
b2Shape.asPolygon = new_instancemethod(_Box2D2.b2Shape_asPolygon,None,b2Shape)
b2Shape.pyGetUserData = new_instancemethod(_Box2D2.b2Shape_pyGetUserData,None,b2Shape)
b2Shape_swigregister = _Box2D2.b2Shape_swigregister
b2Shape_swigregister(b2Shape)

def b2JointInfo(self):
    """Return a rather verbose string representation of a joint"""
    props = dir(self)
    ignoreList = ('this', 'thisown', 'next', 'prev', 'm_next', 'm_prev')
    info  = []
    for prop in dir(self):
        if prop[:2]=='__' or prop in ignoreList: continue
        if not callable(getattr(self, prop)): 
            info.append(prop + ":")
            info.append(str(getattr(self, prop)))
    return "%s(%s)" % (self.__class__.__name__, " ".join(info))

e_unknownJoint = _Box2D2.e_unknownJoint
e_revoluteJoint = _Box2D2.e_revoluteJoint
e_prismaticJoint = _Box2D2.e_prismaticJoint
e_distanceJoint = _Box2D2.e_distanceJoint
e_pulleyJoint = _Box2D2.e_pulleyJoint
e_mouseJoint = _Box2D2.e_mouseJoint
e_gearJoint = _Box2D2.e_gearJoint
e_inactiveLimit = _Box2D2.e_inactiveLimit
e_atLowerLimit = _Box2D2.e_atLowerLimit
e_atUpperLimit = _Box2D2.e_atUpperLimit
e_equalLimits = _Box2D2.e_equalLimits
class b2Jacobian(object):
    """Proxy of C++ b2Jacobian class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    linear1 = _swig_property(_Box2D2.b2Jacobian_linear1_get, _Box2D2.b2Jacobian_linear1_set)
    angular1 = _swig_property(_Box2D2.b2Jacobian_angular1_get, _Box2D2.b2Jacobian_angular1_set)
    linear2 = _swig_property(_Box2D2.b2Jacobian_linear2_get, _Box2D2.b2Jacobian_linear2_set)
    angular2 = _swig_property(_Box2D2.b2Jacobian_angular2_get, _Box2D2.b2Jacobian_angular2_set)
    def SetZero(*args):
        """SetZero(self)"""
        return _Box2D2.b2Jacobian_SetZero(*args)

    def Set(*args):
        """Set(self, b2Vec2 x1, float32 a1, b2Vec2 x2, float32 a2)"""
        return _Box2D2.b2Jacobian_Set(*args)

    def Compute(*args):
        """Compute(self, b2Vec2 x1, float32 a1, b2Vec2 x2, float32 a2) -> float32"""
        return _Box2D2.b2Jacobian_Compute(*args)

    def __repr__(self):
        return "b2Jacobian(linear1: %s: linear2: %s angular1: %s angular2: %s)" %\
            (self.linear1, self.linear2, self.angular1, self.angular2)

    def __init__(self, *args): 
        """__init__(self) -> b2Jacobian"""
        _Box2D2.b2Jacobian_swiginit(self,_Box2D2.new_b2Jacobian(*args))
    __swig_destroy__ = _Box2D2.delete_b2Jacobian
b2Jacobian.SetZero = new_instancemethod(_Box2D2.b2Jacobian_SetZero,None,b2Jacobian)
b2Jacobian.Set = new_instancemethod(_Box2D2.b2Jacobian_Set,None,b2Jacobian)
b2Jacobian.Compute = new_instancemethod(_Box2D2.b2Jacobian_Compute,None,b2Jacobian)
b2Jacobian_swigregister = _Box2D2.b2Jacobian_swigregister
b2Jacobian_swigregister(b2Jacobian)

class b2JointEdge(object):
    """Proxy of C++ b2JointEdge class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    other = _swig_property(_Box2D2.b2JointEdge_other_get, _Box2D2.b2JointEdge_other_set)
    joint = _swig_property(_Box2D2.b2JointEdge_joint_get, _Box2D2.b2JointEdge_joint_set)
    prev = _swig_property(_Box2D2.b2JointEdge_prev_get, _Box2D2.b2JointEdge_prev_set)
    next = _swig_property(_Box2D2.b2JointEdge_next_get, _Box2D2.b2JointEdge_next_set)
    def __repr__(self):
        return "b2JointEdge(other: %s)" % (self.other)

    def __init__(self, *args): 
        """__init__(self) -> b2JointEdge"""
        _Box2D2.b2JointEdge_swiginit(self,_Box2D2.new_b2JointEdge(*args))
    __swig_destroy__ = _Box2D2.delete_b2JointEdge
b2JointEdge_swigregister = _Box2D2.b2JointEdge_swigregister
b2JointEdge_swigregister(b2JointEdge)

class b2JointDef(object):
    """Proxy of C++ b2JointDef class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self) -> b2JointDef"""
        _Box2D2.b2JointDef_swiginit(self,_Box2D2.new_b2JointDef(*args))
    type = _swig_property(_Box2D2.b2JointDef_type_get, _Box2D2.b2JointDef_type_set)
    userData = _swig_property(_Box2D2.b2JointDef_userData_get, _Box2D2.b2JointDef_userData_set)
    body1 = _swig_property(_Box2D2.b2JointDef_body1_get, _Box2D2.b2JointDef_body1_set)
    body2 = _swig_property(_Box2D2.b2JointDef_body2_get, _Box2D2.b2JointDef_body2_set)
    collideConnected = _swig_property(_Box2D2.b2JointDef_collideConnected_get, _Box2D2.b2JointDef_collideConnected_set)
    def __repr__(self):
        return "b2JointDef(body1: %s body2: %s)" % (self.body1, self.body2)
    def typeName(self):
        types = { e_unknownJoint  : "Unknown",
                  e_mouseJoint    : "Mouse", 
                  e_gearJoint     : "Gear",
                  e_distanceJoint : "Distance",
                  e_prismaticJoint: "Prismatic",
                  e_pulleyJoint   : "Pulley",
                  e_revoluteJoint : "Revolute" }
        return types[self.GetType()]

    __swig_destroy__ = _Box2D2.delete_b2JointDef
b2JointDef_swigregister = _Box2D2.b2JointDef_swigregister
b2JointDef_swigregister(b2JointDef)

class b2Joint(object):
    """Proxy of C++ b2Joint class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    def GetType(*args):
        """GetType(self) -> b2JointType"""
        return _Box2D2.b2Joint_GetType(*args)

    def GetBody1(*args):
        """GetBody1(self) -> b2Body"""
        return _Box2D2.b2Joint_GetBody1(*args)

    def GetBody2(*args):
        """GetBody2(self) -> b2Body"""
        return _Box2D2.b2Joint_GetBody2(*args)

    def GetAnchor1(*args):
        """GetAnchor1(self) -> b2Vec2"""
        return _Box2D2.b2Joint_GetAnchor1(*args)

    def GetAnchor2(*args):
        """GetAnchor2(self) -> b2Vec2"""
        return _Box2D2.b2Joint_GetAnchor2(*args)

    def GetReactionForce(*args):
        """GetReactionForce(self) -> b2Vec2"""
        return _Box2D2.b2Joint_GetReactionForce(*args)

    def GetReactionTorque(*args):
        """GetReactionTorque(self) -> float32"""
        return _Box2D2.b2Joint_GetReactionTorque(*args)

    def GetNext(*args):
        """GetNext(self) -> b2Joint"""
        return _Box2D2.b2Joint_GetNext(*args)

    def GetUserData(self): # override the C++ version as it does not work. 
        """Get the specified userData (m_userData)"""
        return self.pyGetUserData()


    def SetUserData(*args):
        """SetUserData(self, void data)"""
        return _Box2D2.b2Joint_SetUserData(*args)

    def __repr__(self):
        return "b2Joint(m_body1: %s m_body2: %s getAsType(): %s)" % (self.m_body1, self.m_body2, self.getAsType())
    def typeName(self):
        types = { e_unknownJoint  : "Unknown",
                  e_mouseJoint    : "Mouse", 
                  e_gearJoint     : "Gear",
                  e_distanceJoint : "Distance",
                  e_prismaticJoint: "Prismatic",
                  e_pulleyJoint   : "Pulley",
                  e_revoluteJoint : "Revolute" }
        return types[self.GetType()]
    def getAsType(self):
        """Return a typecasted version of the joint"""
        return (getattr(self, "as%sJoint" % self.typeName())) ()

    def pyGetUserData(*args):
        """pyGetUserData(self) -> PyObject"""
        return _Box2D2.b2Joint_pyGetUserData(*args)

    def asMouseJoint(*args):
        """asMouseJoint(self) -> b2MouseJoint"""
        return _Box2D2.b2Joint_asMouseJoint(*args)

    def asGearJoint(*args):
        """asGearJoint(self) -> b2GearJoint"""
        return _Box2D2.b2Joint_asGearJoint(*args)

    def asDistanceJoint(*args):
        """asDistanceJoint(self) -> b2DistanceJoint"""
        return _Box2D2.b2Joint_asDistanceJoint(*args)

    def asPrismaticJoint(*args):
        """asPrismaticJoint(self) -> b2PrismaticJoint"""
        return _Box2D2.b2Joint_asPrismaticJoint(*args)

    def asPulleyJoint(*args):
        """asPulleyJoint(self) -> b2PulleyJoint"""
        return _Box2D2.b2Joint_asPulleyJoint(*args)

    def asRevoluteJoint(*args):
        """asRevoluteJoint(self) -> b2RevoluteJoint"""
        return _Box2D2.b2Joint_asRevoluteJoint(*args)

b2Joint.GetType = new_instancemethod(_Box2D2.b2Joint_GetType,None,b2Joint)
b2Joint.GetBody1 = new_instancemethod(_Box2D2.b2Joint_GetBody1,None,b2Joint)
b2Joint.GetBody2 = new_instancemethod(_Box2D2.b2Joint_GetBody2,None,b2Joint)
b2Joint.GetAnchor1 = new_instancemethod(_Box2D2.b2Joint_GetAnchor1,None,b2Joint)
b2Joint.GetAnchor2 = new_instancemethod(_Box2D2.b2Joint_GetAnchor2,None,b2Joint)
b2Joint.GetReactionForce = new_instancemethod(_Box2D2.b2Joint_GetReactionForce,None,b2Joint)
b2Joint.GetReactionTorque = new_instancemethod(_Box2D2.b2Joint_GetReactionTorque,None,b2Joint)
b2Joint.GetNext = new_instancemethod(_Box2D2.b2Joint_GetNext,None,b2Joint)
b2Joint.SetUserData = new_instancemethod(_Box2D2.b2Joint_SetUserData,None,b2Joint)
b2Joint.pyGetUserData = new_instancemethod(_Box2D2.b2Joint_pyGetUserData,None,b2Joint)
b2Joint.asMouseJoint = new_instancemethod(_Box2D2.b2Joint_asMouseJoint,None,b2Joint)
b2Joint.asGearJoint = new_instancemethod(_Box2D2.b2Joint_asGearJoint,None,b2Joint)
b2Joint.asDistanceJoint = new_instancemethod(_Box2D2.b2Joint_asDistanceJoint,None,b2Joint)
b2Joint.asPrismaticJoint = new_instancemethod(_Box2D2.b2Joint_asPrismaticJoint,None,b2Joint)
b2Joint.asPulleyJoint = new_instancemethod(_Box2D2.b2Joint_asPulleyJoint,None,b2Joint)
b2Joint.asRevoluteJoint = new_instancemethod(_Box2D2.b2Joint_asRevoluteJoint,None,b2Joint)
b2Joint_swigregister = _Box2D2.b2Joint_swigregister
b2Joint_swigregister(b2Joint)

class b2CircleDef(b2ShapeDef):
    """Proxy of C++ b2CircleDef class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self) -> b2CircleDef"""
        _Box2D2.b2CircleDef_swiginit(self,_Box2D2.new_b2CircleDef(*args))
    localPosition = _swig_property(_Box2D2.b2CircleDef_localPosition_get, _Box2D2.b2CircleDef_localPosition_set)
    radius = _swig_property(_Box2D2.b2CircleDef_radius_get, _Box2D2.b2CircleDef_radius_set)
    __swig_destroy__ = _Box2D2.delete_b2CircleDef
b2CircleDef_swigregister = _Box2D2.b2CircleDef_swigregister
b2CircleDef_swigregister(b2CircleDef)

class b2CircleShape(b2Shape):
    """Proxy of C++ b2CircleShape class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    def GetLocalPosition(*args):
        """GetLocalPosition(self) -> b2Vec2"""
        return _Box2D2.b2CircleShape_GetLocalPosition(*args)

    def GetRadius(*args):
        """GetRadius(self) -> float32"""
        return _Box2D2.b2CircleShape_GetRadius(*args)

    __swig_destroy__ = _Box2D2.delete_b2CircleShape
b2CircleShape.GetLocalPosition = new_instancemethod(_Box2D2.b2CircleShape_GetLocalPosition,None,b2CircleShape)
b2CircleShape.GetRadius = new_instancemethod(_Box2D2.b2CircleShape_GetRadius,None,b2CircleShape)
b2CircleShape_swigregister = _Box2D2.b2CircleShape_swigregister
b2CircleShape_swigregister(b2CircleShape)

class b2PolygonDef(b2ShapeDef):
    """Proxy of C++ b2PolygonDef class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self) -> b2PolygonDef"""
        _Box2D2.b2PolygonDef_swiginit(self,_Box2D2.new_b2PolygonDef(*args))
    def SetAsBox(*args):
        """
        SetAsBox(self, float32 hx, float32 hy)
        SetAsBox(self, float32 hx, float32 hy, b2Vec2 center, float32 angle)
        """
        return _Box2D2.b2PolygonDef_SetAsBox(*args)

    vertices = _swig_property(_Box2D2.b2PolygonDef_vertices_get, _Box2D2.b2PolygonDef_vertices_set)
    vertexCount = _swig_property(_Box2D2.b2PolygonDef_vertexCount_get, _Box2D2.b2PolygonDef_vertexCount_set)
    def __repr__(self):
        return "b2PolygonDef(vertices: %s count: %d)" % (self.getVertices_tuple(), self.vertexCount)
    def getVertices_tuple(self):
        """Returns all of the vertices as a list of tuples [ (x1,y1), (x2,y2) ... (xN,yN) ]"""
        vertices = []
        for i in range(0, self.vertexCount):
            vertices.append( (self.getVertex(i).x, self.getVertex(i).y ) )
        return vertices
    def getVertices_b2Vec2(self):
        """Returns all of the vertices as a list of b2Vec2's [ (x1,y1), (x2,y2) ... (xN,yN) ]"""
        vertices = []
        for i in range(0, self.vertexCount):
            vertices.append(self.getVertex(i))
        return vertices
    def setVertices_tuple(self, vertices):
        """Sets all of the vertices (up to b2_maxPolygonVertices) given a tuple 
            in the format ( (x1,y1), (x2,y2) ... (xN,yN) )"""
        if len(vertices) > b2_maxPolygonVertices:
            raise ValueError
        self.vertexCount = len(vertices)
        for i in range(0, self.vertexCount):
            self.setVertex(i, vertices[i][0], vertices[i][1])
    def setVertices_b2Vec2(self, vertices):
        """Sets all of the vertices (up to b2_maxPolygonVertices) given a tuple 
            in the format ( (x1,y1), (x2,y2) ... (xN,yN) ) where each vertex
            is a b2Vec2"""
        if len(vertices) > b2_maxPolygonVertices:
            raise ValueError
        self.vertexCount = len(vertices)
        for i in range(0, self.vertexCount):
            self.setVertex(i, vertices[i])

    def getVertex(*args):
        """getVertex(self, uint16 vnum) -> b2Vec2"""
        return _Box2D2.b2PolygonDef_getVertex(*args)

    def setVertex(*args):
        """
        setVertex(self, uint16 vnum, b2Vec2 value)
        setVertex(self, uint16 vnum, float32 x, float32 y)
        """
        return _Box2D2.b2PolygonDef_setVertex(*args)

    __swig_destroy__ = _Box2D2.delete_b2PolygonDef
b2PolygonDef.SetAsBox = new_instancemethod(_Box2D2.b2PolygonDef_SetAsBox,None,b2PolygonDef)
b2PolygonDef.getVertex = new_instancemethod(_Box2D2.b2PolygonDef_getVertex,None,b2PolygonDef)
b2PolygonDef.setVertex = new_instancemethod(_Box2D2.b2PolygonDef_setVertex,None,b2PolygonDef)
b2PolygonDef_swigregister = _Box2D2.b2PolygonDef_swigregister
b2PolygonDef_swigregister(b2PolygonDef)

class b2PolygonShape(b2Shape):
    """Proxy of C++ b2PolygonShape class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    def GetOBB(*args):
        """GetOBB(self) -> b2OBB"""
        return _Box2D2.b2PolygonShape_GetOBB(*args)

    def GetCentroid(*args):
        """GetCentroid(self) -> b2Vec2"""
        return _Box2D2.b2PolygonShape_GetCentroid(*args)

    def GetVertexCount(*args):
        """GetVertexCount(self) -> int32"""
        return _Box2D2.b2PolygonShape_GetVertexCount(*args)

    def GetCoreVertices(*args):
        """GetCoreVertices(self) -> b2Vec2"""
        return _Box2D2.b2PolygonShape_GetCoreVertices(*args)

    def GetNormals(*args):
        """GetNormals(self) -> b2Vec2"""
        return _Box2D2.b2PolygonShape_GetNormals(*args)

    def GetFirstVertex(*args):
        """GetFirstVertex(self, b2XForm xf) -> b2Vec2"""
        return _Box2D2.b2PolygonShape_GetFirstVertex(*args)

    def Centroid(*args):
        """Centroid(self, b2XForm xf) -> b2Vec2"""
        return _Box2D2.b2PolygonShape_Centroid(*args)

    def Support(*args):
        """Support(self, b2XForm xf, b2Vec2 d) -> b2Vec2"""
        return _Box2D2.b2PolygonShape_Support(*args)

    def __repr__(self):
        return "b2PolygonShape(vertices: %s count: %d)" % (self.getVertices_tuple(), self.vertexCount)
    def getVertices_tuple(self):
        """Returns all of the vertices as a list of tuples [ (x1,y1), (x2,y2) ... (xN,yN) ]"""
        vertices = []
        for i in range(0, self.vertexCount):
            vertices.append( (self.getVertex(i).x, self.getVertex(i).y ) )
        return vertices
    def getVertices_b2Vec2(self):
        """Returns all of the vertices as a list of b2Vec2's [ (x1,y1), (x2,y2) ... (xN,yN) ]"""
        vertices = []
        for i in range(0, self.GetVertexCount()):
            vertices.append(self.getVertex(i))
        return vertices

    def getVertex(*args):
        """getVertex(self, uint16 vnum) -> b2Vec2"""
        return _Box2D2.b2PolygonShape_getVertex(*args)

    __swig_destroy__ = _Box2D2.delete_b2PolygonShape
b2PolygonShape.GetOBB = new_instancemethod(_Box2D2.b2PolygonShape_GetOBB,None,b2PolygonShape)
b2PolygonShape.GetCentroid = new_instancemethod(_Box2D2.b2PolygonShape_GetCentroid,None,b2PolygonShape)
b2PolygonShape.GetVertexCount = new_instancemethod(_Box2D2.b2PolygonShape_GetVertexCount,None,b2PolygonShape)
b2PolygonShape.GetCoreVertices = new_instancemethod(_Box2D2.b2PolygonShape_GetCoreVertices,None,b2PolygonShape)
b2PolygonShape.GetNormals = new_instancemethod(_Box2D2.b2PolygonShape_GetNormals,None,b2PolygonShape)
b2PolygonShape.GetFirstVertex = new_instancemethod(_Box2D2.b2PolygonShape_GetFirstVertex,None,b2PolygonShape)
b2PolygonShape.Centroid = new_instancemethod(_Box2D2.b2PolygonShape_Centroid,None,b2PolygonShape)
b2PolygonShape.Support = new_instancemethod(_Box2D2.b2PolygonShape_Support,None,b2PolygonShape)
b2PolygonShape.getVertex = new_instancemethod(_Box2D2.b2PolygonShape_getVertex,None,b2PolygonShape)
b2PolygonShape_swigregister = _Box2D2.b2PolygonShape_swigregister
b2PolygonShape_swigregister(b2PolygonShape)

class b2Pair(object):
    """Proxy of C++ b2Pair class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    e_pairBuffered = _Box2D2.b2Pair_e_pairBuffered
    e_pairRemoved = _Box2D2.b2Pair_e_pairRemoved
    e_pairFinal = _Box2D2.b2Pair_e_pairFinal
    def SetBuffered(*args):
        """SetBuffered(self)"""
        return _Box2D2.b2Pair_SetBuffered(*args)

    def ClearBuffered(*args):
        """ClearBuffered(self)"""
        return _Box2D2.b2Pair_ClearBuffered(*args)

    def IsBuffered(*args):
        """IsBuffered(self) -> bool"""
        return _Box2D2.b2Pair_IsBuffered(*args)

    def SetRemoved(*args):
        """SetRemoved(self)"""
        return _Box2D2.b2Pair_SetRemoved(*args)

    def ClearRemoved(*args):
        """ClearRemoved(self)"""
        return _Box2D2.b2Pair_ClearRemoved(*args)

    def IsRemoved(*args):
        """IsRemoved(self) -> bool"""
        return _Box2D2.b2Pair_IsRemoved(*args)

    def SetFinal(*args):
        """SetFinal(self)"""
        return _Box2D2.b2Pair_SetFinal(*args)

    def IsFinal(*args):
        """IsFinal(self) -> bool"""
        return _Box2D2.b2Pair_IsFinal(*args)

    userData = _swig_property(_Box2D2.b2Pair_userData_get, _Box2D2.b2Pair_userData_set)
    proxyId1 = _swig_property(_Box2D2.b2Pair_proxyId1_get, _Box2D2.b2Pair_proxyId1_set)
    proxyId2 = _swig_property(_Box2D2.b2Pair_proxyId2_get, _Box2D2.b2Pair_proxyId2_set)
    next = _swig_property(_Box2D2.b2Pair_next_get, _Box2D2.b2Pair_next_set)
    status = _swig_property(_Box2D2.b2Pair_status_get, _Box2D2.b2Pair_status_set)
    def __init__(self, *args): 
        """__init__(self) -> b2Pair"""
        _Box2D2.b2Pair_swiginit(self,_Box2D2.new_b2Pair(*args))
    __swig_destroy__ = _Box2D2.delete_b2Pair
b2Pair.SetBuffered = new_instancemethod(_Box2D2.b2Pair_SetBuffered,None,b2Pair)
b2Pair.ClearBuffered = new_instancemethod(_Box2D2.b2Pair_ClearBuffered,None,b2Pair)
b2Pair.IsBuffered = new_instancemethod(_Box2D2.b2Pair_IsBuffered,None,b2Pair)
b2Pair.SetRemoved = new_instancemethod(_Box2D2.b2Pair_SetRemoved,None,b2Pair)
b2Pair.ClearRemoved = new_instancemethod(_Box2D2.b2Pair_ClearRemoved,None,b2Pair)
b2Pair.IsRemoved = new_instancemethod(_Box2D2.b2Pair_IsRemoved,None,b2Pair)
b2Pair.SetFinal = new_instancemethod(_Box2D2.b2Pair_SetFinal,None,b2Pair)
b2Pair.IsFinal = new_instancemethod(_Box2D2.b2Pair_IsFinal,None,b2Pair)
b2Pair_swigregister = _Box2D2.b2Pair_swigregister
b2Pair_swigregister(b2Pair)
b2_nullPair = cvar.b2_nullPair
b2_nullProxy = cvar.b2_nullProxy
b2_tableCapacity = cvar.b2_tableCapacity
b2_tableMask = cvar.b2_tableMask

class b2BufferedPair(object):
    """Proxy of C++ b2BufferedPair class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    proxyId1 = _swig_property(_Box2D2.b2BufferedPair_proxyId1_get, _Box2D2.b2BufferedPair_proxyId1_set)
    proxyId2 = _swig_property(_Box2D2.b2BufferedPair_proxyId2_get, _Box2D2.b2BufferedPair_proxyId2_set)
    def __init__(self, *args): 
        """__init__(self) -> b2BufferedPair"""
        _Box2D2.b2BufferedPair_swiginit(self,_Box2D2.new_b2BufferedPair(*args))
    __swig_destroy__ = _Box2D2.delete_b2BufferedPair
b2BufferedPair_swigregister = _Box2D2.b2BufferedPair_swigregister
b2BufferedPair_swigregister(b2BufferedPair)

class b2PairCallback(object):
    """Proxy of C++ b2PairCallback class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _Box2D2.delete_b2PairCallback
    def PairAdded(*args):
        """PairAdded(self, void proxyUserData1, void proxyUserData2) -> void"""
        return _Box2D2.b2PairCallback_PairAdded(*args)

    def PairRemoved(*args):
        """PairRemoved(self, void proxyUserData1, void proxyUserData2, void pairUserData)"""
        return _Box2D2.b2PairCallback_PairRemoved(*args)

b2PairCallback.PairAdded = new_instancemethod(_Box2D2.b2PairCallback_PairAdded,None,b2PairCallback)
b2PairCallback.PairRemoved = new_instancemethod(_Box2D2.b2PairCallback_PairRemoved,None,b2PairCallback)
b2PairCallback_swigregister = _Box2D2.b2PairCallback_swigregister
b2PairCallback_swigregister(b2PairCallback)

class b2PairManager(object):
    """Proxy of C++ b2PairManager class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self) -> b2PairManager"""
        _Box2D2.b2PairManager_swiginit(self,_Box2D2.new_b2PairManager(*args))
    def Initialize(*args):
        """Initialize(self, b2BroadPhase broadPhase, b2PairCallback callback)"""
        return _Box2D2.b2PairManager_Initialize(*args)

    def AddBufferedPair(*args):
        """AddBufferedPair(self, int32 proxyId1, int32 proxyId2)"""
        return _Box2D2.b2PairManager_AddBufferedPair(*args)

    def RemoveBufferedPair(*args):
        """RemoveBufferedPair(self, int32 proxyId1, int32 proxyId2)"""
        return _Box2D2.b2PairManager_RemoveBufferedPair(*args)

    def Commit(*args):
        """Commit(self)"""
        return _Box2D2.b2PairManager_Commit(*args)

    m_broadPhase = _swig_property(_Box2D2.b2PairManager_m_broadPhase_get, _Box2D2.b2PairManager_m_broadPhase_set)
    m_callback = _swig_property(_Box2D2.b2PairManager_m_callback_get, _Box2D2.b2PairManager_m_callback_set)
    m_pairs = _swig_property(_Box2D2.b2PairManager_m_pairs_get, _Box2D2.b2PairManager_m_pairs_set)
    m_freePair = _swig_property(_Box2D2.b2PairManager_m_freePair_get, _Box2D2.b2PairManager_m_freePair_set)
    m_pairCount = _swig_property(_Box2D2.b2PairManager_m_pairCount_get, _Box2D2.b2PairManager_m_pairCount_set)
    m_pairBuffer = _swig_property(_Box2D2.b2PairManager_m_pairBuffer_get, _Box2D2.b2PairManager_m_pairBuffer_set)
    m_pairBufferCount = _swig_property(_Box2D2.b2PairManager_m_pairBufferCount_get, _Box2D2.b2PairManager_m_pairBufferCount_set)
    m_hashTable = _swig_property(_Box2D2.b2PairManager_m_hashTable_get, _Box2D2.b2PairManager_m_hashTable_set)
    __swig_destroy__ = _Box2D2.delete_b2PairManager
b2PairManager.Initialize = new_instancemethod(_Box2D2.b2PairManager_Initialize,None,b2PairManager)
b2PairManager.AddBufferedPair = new_instancemethod(_Box2D2.b2PairManager_AddBufferedPair,None,b2PairManager)
b2PairManager.RemoveBufferedPair = new_instancemethod(_Box2D2.b2PairManager_RemoveBufferedPair,None,b2PairManager)
b2PairManager.Commit = new_instancemethod(_Box2D2.b2PairManager_Commit,None,b2PairManager)
b2PairManager_swigregister = _Box2D2.b2PairManager_swigregister
b2PairManager_swigregister(b2PairManager)

class b2Bound(object):
    """Proxy of C++ b2Bound class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def IsLower(*args):
        """IsLower(self) -> bool"""
        return _Box2D2.b2Bound_IsLower(*args)

    def IsUpper(*args):
        """IsUpper(self) -> bool"""
        return _Box2D2.b2Bound_IsUpper(*args)

    value = _swig_property(_Box2D2.b2Bound_value_get, _Box2D2.b2Bound_value_set)
    proxyId = _swig_property(_Box2D2.b2Bound_proxyId_get, _Box2D2.b2Bound_proxyId_set)
    stabbingCount = _swig_property(_Box2D2.b2Bound_stabbingCount_get, _Box2D2.b2Bound_stabbingCount_set)
    def __init__(self, *args): 
        """__init__(self) -> b2Bound"""
        _Box2D2.b2Bound_swiginit(self,_Box2D2.new_b2Bound(*args))
    __swig_destroy__ = _Box2D2.delete_b2Bound
b2Bound.IsLower = new_instancemethod(_Box2D2.b2Bound_IsLower,None,b2Bound)
b2Bound.IsUpper = new_instancemethod(_Box2D2.b2Bound_IsUpper,None,b2Bound)
b2Bound_swigregister = _Box2D2.b2Bound_swigregister
b2Bound_swigregister(b2Bound)
b2_invalid = cvar.b2_invalid
b2_nullEdge = cvar.b2_nullEdge

class b2Proxy(object):
    """Proxy of C++ b2Proxy class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def GetNext(*args):
        """GetNext(self) -> uint16"""
        return _Box2D2.b2Proxy_GetNext(*args)

    def SetNext(*args):
        """SetNext(self, uint16 next)"""
        return _Box2D2.b2Proxy_SetNext(*args)

    def IsValid(*args):
        """IsValid(self) -> bool"""
        return _Box2D2.b2Proxy_IsValid(*args)

    lowerBounds = _swig_property(_Box2D2.b2Proxy_lowerBounds_get, _Box2D2.b2Proxy_lowerBounds_set)
    upperBounds = _swig_property(_Box2D2.b2Proxy_upperBounds_get, _Box2D2.b2Proxy_upperBounds_set)
    overlapCount = _swig_property(_Box2D2.b2Proxy_overlapCount_get, _Box2D2.b2Proxy_overlapCount_set)
    timeStamp = _swig_property(_Box2D2.b2Proxy_timeStamp_get, _Box2D2.b2Proxy_timeStamp_set)
    userData = _swig_property(_Box2D2.b2Proxy_userData_get, _Box2D2.b2Proxy_userData_set)
    def __init__(self, *args): 
        """__init__(self) -> b2Proxy"""
        _Box2D2.b2Proxy_swiginit(self,_Box2D2.new_b2Proxy(*args))
    __swig_destroy__ = _Box2D2.delete_b2Proxy
b2Proxy.GetNext = new_instancemethod(_Box2D2.b2Proxy_GetNext,None,b2Proxy)
b2Proxy.SetNext = new_instancemethod(_Box2D2.b2Proxy_SetNext,None,b2Proxy)
b2Proxy.IsValid = new_instancemethod(_Box2D2.b2Proxy_IsValid,None,b2Proxy)
b2Proxy_swigregister = _Box2D2.b2Proxy_swigregister
b2Proxy_swigregister(b2Proxy)

class b2BroadPhase(object):
    """Proxy of C++ b2BroadPhase class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, b2AABB worldAABB, b2PairCallback callback) -> b2BroadPhase"""
        _Box2D2.b2BroadPhase_swiginit(self,_Box2D2.new_b2BroadPhase(*args))
    __swig_destroy__ = _Box2D2.delete_b2BroadPhase
    def InRange(*args):
        """InRange(self, b2AABB aabb) -> bool"""
        return _Box2D2.b2BroadPhase_InRange(*args)

    def CreateProxy(*args):
        """CreateProxy(self, b2AABB aabb, void userData) -> uint16"""
        return _Box2D2.b2BroadPhase_CreateProxy(*args)

    def DestroyProxy(*args):
        """DestroyProxy(self, int32 proxyId)"""
        return _Box2D2.b2BroadPhase_DestroyProxy(*args)

    def MoveProxy(*args):
        """MoveProxy(self, int32 proxyId, b2AABB aabb)"""
        return _Box2D2.b2BroadPhase_MoveProxy(*args)

    def Commit(*args):
        """Commit(self)"""
        return _Box2D2.b2BroadPhase_Commit(*args)

    def GetProxy(*args):
        """GetProxy(self, int32 proxyId) -> b2Proxy"""
        return _Box2D2.b2BroadPhase_GetProxy(*args)

    def Query(*args):
        """Query(self, b2AABB aabb, void userData, int32 maxCount) -> int32"""
        return _Box2D2.b2BroadPhase_Query(*args)

    def Validate(*args):
        """Validate(self)"""
        return _Box2D2.b2BroadPhase_Validate(*args)

    def ValidatePairs(*args):
        """ValidatePairs(self)"""
        return _Box2D2.b2BroadPhase_ValidatePairs(*args)

    m_pairManager = _swig_property(_Box2D2.b2BroadPhase_m_pairManager_get, _Box2D2.b2BroadPhase_m_pairManager_set)
    m_proxyPool = _swig_property(_Box2D2.b2BroadPhase_m_proxyPool_get, _Box2D2.b2BroadPhase_m_proxyPool_set)
    m_freeProxy = _swig_property(_Box2D2.b2BroadPhase_m_freeProxy_get, _Box2D2.b2BroadPhase_m_freeProxy_set)
    m_bounds = _swig_property(_Box2D2.b2BroadPhase_m_bounds_get, _Box2D2.b2BroadPhase_m_bounds_set)
    m_queryResults = _swig_property(_Box2D2.b2BroadPhase_m_queryResults_get, _Box2D2.b2BroadPhase_m_queryResults_set)
    m_queryResultCount = _swig_property(_Box2D2.b2BroadPhase_m_queryResultCount_get, _Box2D2.b2BroadPhase_m_queryResultCount_set)
    m_worldAABB = _swig_property(_Box2D2.b2BroadPhase_m_worldAABB_get, _Box2D2.b2BroadPhase_m_worldAABB_set)
    m_quantizationFactor = _swig_property(_Box2D2.b2BroadPhase_m_quantizationFactor_get, _Box2D2.b2BroadPhase_m_quantizationFactor_set)
    m_proxyCount = _swig_property(_Box2D2.b2BroadPhase_m_proxyCount_get, _Box2D2.b2BroadPhase_m_proxyCount_set)
    m_timeStamp = _swig_property(_Box2D2.b2BroadPhase_m_timeStamp_get, _Box2D2.b2BroadPhase_m_timeStamp_set)
    s_validate = _swig_property(_Box2D2.b2BroadPhase_s_validate_get, _Box2D2.b2BroadPhase_s_validate_set)
b2BroadPhase.InRange = new_instancemethod(_Box2D2.b2BroadPhase_InRange,None,b2BroadPhase)
b2BroadPhase.CreateProxy = new_instancemethod(_Box2D2.b2BroadPhase_CreateProxy,None,b2BroadPhase)
b2BroadPhase.DestroyProxy = new_instancemethod(_Box2D2.b2BroadPhase_DestroyProxy,None,b2BroadPhase)
b2BroadPhase.MoveProxy = new_instancemethod(_Box2D2.b2BroadPhase_MoveProxy,None,b2BroadPhase)
b2BroadPhase.Commit = new_instancemethod(_Box2D2.b2BroadPhase_Commit,None,b2BroadPhase)
b2BroadPhase.GetProxy = new_instancemethod(_Box2D2.b2BroadPhase_GetProxy,None,b2BroadPhase)
b2BroadPhase.Query = new_instancemethod(_Box2D2.b2BroadPhase_Query,None,b2BroadPhase)
b2BroadPhase.Validate = new_instancemethod(_Box2D2.b2BroadPhase_Validate,None,b2BroadPhase)
b2BroadPhase.ValidatePairs = new_instancemethod(_Box2D2.b2BroadPhase_ValidatePairs,None,b2BroadPhase)
b2BroadPhase_swigregister = _Box2D2.b2BroadPhase_swigregister
b2BroadPhase_swigregister(b2BroadPhase)

class b2DestructionListener(object):
    """Proxy of C++ b2DestructionListener class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _Box2D2.delete_b2DestructionListener
    def SayGoodbye(*args):
        """
        SayGoodbye(self, b2Joint joint)
        SayGoodbye(self, b2Shape shape)
        """
        return _Box2D2.b2DestructionListener_SayGoodbye(*args)

    def __init__(self, *args): 
        """__init__(self) -> b2DestructionListener"""
        if self.__class__ == b2DestructionListener:
            args = (None,) + args
        else:
            args = (self,) + args
        _Box2D2.b2DestructionListener_swiginit(self,_Box2D2.new_b2DestructionListener(*args))
    def __disown__(self):
        self.this.disown()
        _Box2D2.disown_b2DestructionListener(self)
        return weakref_proxy(self)
b2DestructionListener.SayGoodbye = new_instancemethod(_Box2D2.b2DestructionListener_SayGoodbye,None,b2DestructionListener)
b2DestructionListener_swigregister = _Box2D2.b2DestructionListener_swigregister
b2DestructionListener_swigregister(b2DestructionListener)

class b2BoundaryListener(object):
    """Proxy of C++ b2BoundaryListener class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _Box2D2.delete_b2BoundaryListener
    def Violation(*args):
        """Violation(self, b2Body body)"""
        return _Box2D2.b2BoundaryListener_Violation(*args)

    def __init__(self, *args): 
        """__init__(self) -> b2BoundaryListener"""
        if self.__class__ == b2BoundaryListener:
            args = (None,) + args
        else:
            args = (self,) + args
        _Box2D2.b2BoundaryListener_swiginit(self,_Box2D2.new_b2BoundaryListener(*args))
    def __disown__(self):
        self.this.disown()
        _Box2D2.disown_b2BoundaryListener(self)
        return weakref_proxy(self)
b2BoundaryListener.Violation = new_instancemethod(_Box2D2.b2BoundaryListener_Violation,None,b2BoundaryListener)
b2BoundaryListener_swigregister = _Box2D2.b2BoundaryListener_swigregister
b2BoundaryListener_swigregister(b2BoundaryListener)

class b2ContactFilter(object):
    """Proxy of C++ b2ContactFilter class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _Box2D2.delete_b2ContactFilter
    def ShouldCollide(*args):
        """ShouldCollide(self, b2Shape shape1, b2Shape shape2) -> bool"""
        return _Box2D2.b2ContactFilter_ShouldCollide(*args)

    def __init__(self, *args): 
        """__init__(self) -> b2ContactFilter"""
        _Box2D2.b2ContactFilter_swiginit(self,_Box2D2.new_b2ContactFilter(*args))
b2ContactFilter.ShouldCollide = new_instancemethod(_Box2D2.b2ContactFilter_ShouldCollide,None,b2ContactFilter)
b2ContactFilter_swigregister = _Box2D2.b2ContactFilter_swigregister
b2ContactFilter_swigregister(b2ContactFilter)

class b2ContactListener(object):
    """Proxy of C++ b2ContactListener class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _Box2D2.delete_b2ContactListener
    def Add(*args):
        """Add(self, b2ContactPoint point)"""
        return _Box2D2.b2ContactListener_Add(*args)

    def Persist(*args):
        """Persist(self, b2ContactPoint point)"""
        return _Box2D2.b2ContactListener_Persist(*args)

    def Remove(*args):
        """Remove(self, b2ContactPoint point)"""
        return _Box2D2.b2ContactListener_Remove(*args)

    def Result(*args):
        """Result(self, b2ContactResult point)"""
        return _Box2D2.b2ContactListener_Result(*args)

    def __init__(self, *args): 
        """__init__(self) -> b2ContactListener"""
        if self.__class__ == b2ContactListener:
            args = (None,) + args
        else:
            args = (self,) + args
        _Box2D2.b2ContactListener_swiginit(self,_Box2D2.new_b2ContactListener(*args))
    def __disown__(self):
        self.this.disown()
        _Box2D2.disown_b2ContactListener(self)
        return weakref_proxy(self)
b2ContactListener.Add = new_instancemethod(_Box2D2.b2ContactListener_Add,None,b2ContactListener)
b2ContactListener.Persist = new_instancemethod(_Box2D2.b2ContactListener_Persist,None,b2ContactListener)
b2ContactListener.Remove = new_instancemethod(_Box2D2.b2ContactListener_Remove,None,b2ContactListener)
b2ContactListener.Result = new_instancemethod(_Box2D2.b2ContactListener_Result,None,b2ContactListener)
b2ContactListener_swigregister = _Box2D2.b2ContactListener_swigregister
b2ContactListener_swigregister(b2ContactListener)

class b2Color(object):
    """Proxy of C++ b2Color class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> b2Color
        __init__(self, float32 r, float32 g, float32 b) -> b2Color
        """
        _Box2D2.b2Color_swiginit(self,_Box2D2.new_b2Color(*args))
    r = _swig_property(_Box2D2.b2Color_r_get, _Box2D2.b2Color_r_set)
    g = _swig_property(_Box2D2.b2Color_g_get, _Box2D2.b2Color_g_set)
    b = _swig_property(_Box2D2.b2Color_b_get, _Box2D2.b2Color_b_set)
    __swig_destroy__ = _Box2D2.delete_b2Color
b2Color_swigregister = _Box2D2.b2Color_swigregister
b2Color_swigregister(b2Color)

class b2DebugDraw(object):
    """Proxy of C++ b2DebugDraw class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self) -> b2DebugDraw"""
        if self.__class__ == b2DebugDraw:
            args = (None,) + args
        else:
            args = (self,) + args
        _Box2D2.b2DebugDraw_swiginit(self,_Box2D2.new_b2DebugDraw(*args))
    __swig_destroy__ = _Box2D2.delete_b2DebugDraw
    e_shapeBit = _Box2D2.b2DebugDraw_e_shapeBit
    e_jointBit = _Box2D2.b2DebugDraw_e_jointBit
    e_coreShapeBit = _Box2D2.b2DebugDraw_e_coreShapeBit
    e_aabbBit = _Box2D2.b2DebugDraw_e_aabbBit
    e_obbBit = _Box2D2.b2DebugDraw_e_obbBit
    e_pairBit = _Box2D2.b2DebugDraw_e_pairBit
    e_centerOfMassBit = _Box2D2.b2DebugDraw_e_centerOfMassBit
    def SetFlags(*args):
        """SetFlags(self, uint32 flags)"""
        return _Box2D2.b2DebugDraw_SetFlags(*args)

    def GetFlags(*args):
        """GetFlags(self) -> uint32"""
        return _Box2D2.b2DebugDraw_GetFlags(*args)

    def AppendFlags(*args):
        """AppendFlags(self, uint32 flags)"""
        return _Box2D2.b2DebugDraw_AppendFlags(*args)

    def ClearFlags(*args):
        """ClearFlags(self, uint32 flags)"""
        return _Box2D2.b2DebugDraw_ClearFlags(*args)

    def DrawPolygon(*args):
        """DrawPolygon(self, b2Vec2 vertices, int32 vertexCount, b2Color color)"""
        return _Box2D2.b2DebugDraw_DrawPolygon(*args)

    def DrawSolidPolygon(*args):
        """DrawSolidPolygon(self, b2Vec2 vertices, int32 vertexCount, b2Color color)"""
        return _Box2D2.b2DebugDraw_DrawSolidPolygon(*args)

    def DrawCircle(*args):
        """DrawCircle(self, b2Vec2 center, float32 radius, b2Color color)"""
        return _Box2D2.b2DebugDraw_DrawCircle(*args)

    def DrawSolidCircle(*args):
        """DrawSolidCircle(self, b2Vec2 center, float32 radius, b2Vec2 axis, b2Color color)"""
        return _Box2D2.b2DebugDraw_DrawSolidCircle(*args)

    def DrawSegment(*args):
        """DrawSegment(self, b2Vec2 p1, b2Vec2 p2, b2Color color)"""
        return _Box2D2.b2DebugDraw_DrawSegment(*args)

    def DrawXForm(*args):
        """DrawXForm(self, b2XForm xf)"""
        return _Box2D2.b2DebugDraw_DrawXForm(*args)

    def __disown__(self):
        self.this.disown()
        _Box2D2.disown_b2DebugDraw(self)
        return weakref_proxy(self)
b2DebugDraw.SetFlags = new_instancemethod(_Box2D2.b2DebugDraw_SetFlags,None,b2DebugDraw)
b2DebugDraw.GetFlags = new_instancemethod(_Box2D2.b2DebugDraw_GetFlags,None,b2DebugDraw)
b2DebugDraw.AppendFlags = new_instancemethod(_Box2D2.b2DebugDraw_AppendFlags,None,b2DebugDraw)
b2DebugDraw.ClearFlags = new_instancemethod(_Box2D2.b2DebugDraw_ClearFlags,None,b2DebugDraw)
b2DebugDraw.DrawPolygon = new_instancemethod(_Box2D2.b2DebugDraw_DrawPolygon,None,b2DebugDraw)
b2DebugDraw.DrawSolidPolygon = new_instancemethod(_Box2D2.b2DebugDraw_DrawSolidPolygon,None,b2DebugDraw)
b2DebugDraw.DrawCircle = new_instancemethod(_Box2D2.b2DebugDraw_DrawCircle,None,b2DebugDraw)
b2DebugDraw.DrawSolidCircle = new_instancemethod(_Box2D2.b2DebugDraw_DrawSolidCircle,None,b2DebugDraw)
b2DebugDraw.DrawSegment = new_instancemethod(_Box2D2.b2DebugDraw_DrawSegment,None,b2DebugDraw)
b2DebugDraw.DrawXForm = new_instancemethod(_Box2D2.b2DebugDraw_DrawXForm,None,b2DebugDraw)
b2DebugDraw_swigregister = _Box2D2.b2DebugDraw_swigregister
b2DebugDraw_swigregister(b2DebugDraw)

class b2BlockAllocator(object):
    """Proxy of C++ b2BlockAllocator class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self) -> b2BlockAllocator"""
        _Box2D2.b2BlockAllocator_swiginit(self,_Box2D2.new_b2BlockAllocator(*args))
    __swig_destroy__ = _Box2D2.delete_b2BlockAllocator
    def Allocate(*args):
        """Allocate(self, int32 size) -> void"""
        return _Box2D2.b2BlockAllocator_Allocate(*args)

    def Free(*args):
        """Free(self, void p, int32 size)"""
        return _Box2D2.b2BlockAllocator_Free(*args)

    def Clear(*args):
        """Clear(self)"""
        return _Box2D2.b2BlockAllocator_Clear(*args)

b2BlockAllocator.Allocate = new_instancemethod(_Box2D2.b2BlockAllocator_Allocate,None,b2BlockAllocator)
b2BlockAllocator.Free = new_instancemethod(_Box2D2.b2BlockAllocator_Free,None,b2BlockAllocator)
b2BlockAllocator.Clear = new_instancemethod(_Box2D2.b2BlockAllocator_Clear,None,b2BlockAllocator)
b2BlockAllocator_swigregister = _Box2D2.b2BlockAllocator_swigregister
b2BlockAllocator_swigregister(b2BlockAllocator)
b2_chunkSize = cvar.b2_chunkSize
b2_maxBlockSize = cvar.b2_maxBlockSize
b2_blockSizes = cvar.b2_blockSizes
b2_chunkArrayIncrement = cvar.b2_chunkArrayIncrement

class b2StackEntry(object):
    """Proxy of C++ b2StackEntry class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    data = _swig_property(_Box2D2.b2StackEntry_data_get, _Box2D2.b2StackEntry_data_set)
    size = _swig_property(_Box2D2.b2StackEntry_size_get, _Box2D2.b2StackEntry_size_set)
    usedMalloc = _swig_property(_Box2D2.b2StackEntry_usedMalloc_get, _Box2D2.b2StackEntry_usedMalloc_set)
    def __init__(self, *args): 
        """__init__(self) -> b2StackEntry"""
        _Box2D2.b2StackEntry_swiginit(self,_Box2D2.new_b2StackEntry(*args))
    __swig_destroy__ = _Box2D2.delete_b2StackEntry
b2StackEntry_swigregister = _Box2D2.b2StackEntry_swigregister
b2StackEntry_swigregister(b2StackEntry)
b2_stackSize = cvar.b2_stackSize
b2_maxStackEntries = cvar.b2_maxStackEntries

class b2StackAllocator(object):
    """Proxy of C++ b2StackAllocator class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self) -> b2StackAllocator"""
        _Box2D2.b2StackAllocator_swiginit(self,_Box2D2.new_b2StackAllocator(*args))
    __swig_destroy__ = _Box2D2.delete_b2StackAllocator
    def Allocate(*args):
        """Allocate(self, int32 size) -> void"""
        return _Box2D2.b2StackAllocator_Allocate(*args)

    def Free(*args):
        """Free(self, void p)"""
        return _Box2D2.b2StackAllocator_Free(*args)

    def GetMaxAllocation(*args):
        """GetMaxAllocation(self) -> int32"""
        return _Box2D2.b2StackAllocator_GetMaxAllocation(*args)

b2StackAllocator.Allocate = new_instancemethod(_Box2D2.b2StackAllocator_Allocate,None,b2StackAllocator)
b2StackAllocator.Free = new_instancemethod(_Box2D2.b2StackAllocator_Free,None,b2StackAllocator)
b2StackAllocator.GetMaxAllocation = new_instancemethod(_Box2D2.b2StackAllocator_GetMaxAllocation,None,b2StackAllocator)
b2StackAllocator_swigregister = _Box2D2.b2StackAllocator_swigregister
b2StackAllocator_swigregister(b2StackAllocator)

class b2ContactRegister(object):
    """Proxy of C++ b2ContactRegister class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    createFcn = _swig_property(_Box2D2.b2ContactRegister_createFcn_get, _Box2D2.b2ContactRegister_createFcn_set)
    destroyFcn = _swig_property(_Box2D2.b2ContactRegister_destroyFcn_get, _Box2D2.b2ContactRegister_destroyFcn_set)
    primary = _swig_property(_Box2D2.b2ContactRegister_primary_get, _Box2D2.b2ContactRegister_primary_set)
    def __init__(self, *args): 
        """__init__(self) -> b2ContactRegister"""
        _Box2D2.b2ContactRegister_swiginit(self,_Box2D2.new_b2ContactRegister(*args))
    __swig_destroy__ = _Box2D2.delete_b2ContactRegister
b2ContactRegister_swigregister = _Box2D2.b2ContactRegister_swigregister
b2ContactRegister_swigregister(b2ContactRegister)

class b2ContactEdge(object):
    """Proxy of C++ b2ContactEdge class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    other = _swig_property(_Box2D2.b2ContactEdge_other_get, _Box2D2.b2ContactEdge_other_set)
    contact = _swig_property(_Box2D2.b2ContactEdge_contact_get, _Box2D2.b2ContactEdge_contact_set)
    prev = _swig_property(_Box2D2.b2ContactEdge_prev_get, _Box2D2.b2ContactEdge_prev_set)
    next = _swig_property(_Box2D2.b2ContactEdge_next_get, _Box2D2.b2ContactEdge_next_set)
    def __init__(self, *args): 
        """__init__(self) -> b2ContactEdge"""
        _Box2D2.b2ContactEdge_swiginit(self,_Box2D2.new_b2ContactEdge(*args))
    __swig_destroy__ = _Box2D2.delete_b2ContactEdge
b2ContactEdge_swigregister = _Box2D2.b2ContactEdge_swigregister
b2ContactEdge_swigregister(b2ContactEdge)

class b2ContactPoint(object):
    """Proxy of C++ b2ContactPoint class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    shape1 = _swig_property(_Box2D2.b2ContactPoint_shape1_get, _Box2D2.b2ContactPoint_shape1_set)
    shape2 = _swig_property(_Box2D2.b2ContactPoint_shape2_get, _Box2D2.b2ContactPoint_shape2_set)
    position = _swig_property(_Box2D2.b2ContactPoint_position_get, _Box2D2.b2ContactPoint_position_set)
    velocity = _swig_property(_Box2D2.b2ContactPoint_velocity_get, _Box2D2.b2ContactPoint_velocity_set)
    normal = _swig_property(_Box2D2.b2ContactPoint_normal_get, _Box2D2.b2ContactPoint_normal_set)
    separation = _swig_property(_Box2D2.b2ContactPoint_separation_get, _Box2D2.b2ContactPoint_separation_set)
    friction = _swig_property(_Box2D2.b2ContactPoint_friction_get, _Box2D2.b2ContactPoint_friction_set)
    restitution = _swig_property(_Box2D2.b2ContactPoint_restitution_get, _Box2D2.b2ContactPoint_restitution_set)
    id = _swig_property(_Box2D2.b2ContactPoint_id_get, _Box2D2.b2ContactPoint_id_set)
    def __repr__(self):
        return "b2ContactPoint(\n\tid: %s\n\tshape1: %s\n\tshape2: %s\n\tposition: %s\n\tnormal: %s\n\tseparation: %f normalForce: %f tangentForce: %f)" % \
            (self.id, self.shape1, self.shape2, self.position, self.normal, self.separation, self.normalForce, self.tangentForce)

    def __init__(self, *args): 
        """__init__(self) -> b2ContactPoint"""
        _Box2D2.b2ContactPoint_swiginit(self,_Box2D2.new_b2ContactPoint(*args))
    __swig_destroy__ = _Box2D2.delete_b2ContactPoint
b2ContactPoint_swigregister = _Box2D2.b2ContactPoint_swigregister
b2ContactPoint_swigregister(b2ContactPoint)

class b2ContactResult(object):
    """Proxy of C++ b2ContactResult class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    shape1 = _swig_property(_Box2D2.b2ContactResult_shape1_get, _Box2D2.b2ContactResult_shape1_set)
    shape2 = _swig_property(_Box2D2.b2ContactResult_shape2_get, _Box2D2.b2ContactResult_shape2_set)
    position = _swig_property(_Box2D2.b2ContactResult_position_get, _Box2D2.b2ContactResult_position_set)
    normal = _swig_property(_Box2D2.b2ContactResult_normal_get, _Box2D2.b2ContactResult_normal_set)
    normalImpulse = _swig_property(_Box2D2.b2ContactResult_normalImpulse_get, _Box2D2.b2ContactResult_normalImpulse_set)
    tangentImpulse = _swig_property(_Box2D2.b2ContactResult_tangentImpulse_get, _Box2D2.b2ContactResult_tangentImpulse_set)
    id = _swig_property(_Box2D2.b2ContactResult_id_get, _Box2D2.b2ContactResult_id_set)
    def __init__(self, *args): 
        """__init__(self) -> b2ContactResult"""
        _Box2D2.b2ContactResult_swiginit(self,_Box2D2.new_b2ContactResult(*args))
    __swig_destroy__ = _Box2D2.delete_b2ContactResult
b2ContactResult_swigregister = _Box2D2.b2ContactResult_swigregister
b2ContactResult_swigregister(b2ContactResult)

class b2Contact(object):
    """Proxy of C++ b2Contact class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    def GetManifolds(*args):
        """GetManifolds(self) -> b2Manifold"""
        return _Box2D2.b2Contact_GetManifolds(*args)

    def GetManifoldCount(*args):
        """GetManifoldCount(self) -> int32"""
        return _Box2D2.b2Contact_GetManifoldCount(*args)

    def IsSolid(*args):
        """IsSolid(self) -> bool"""
        return _Box2D2.b2Contact_IsSolid(*args)

    def GetNext(*args):
        """GetNext(self) -> b2Contact"""
        return _Box2D2.b2Contact_GetNext(*args)

    def GetShape1(*args):
        """GetShape1(self) -> b2Shape"""
        return _Box2D2.b2Contact_GetShape1(*args)

    def GetShape2(*args):
        """GetShape2(self) -> b2Shape"""
        return _Box2D2.b2Contact_GetShape2(*args)

    e_nonSolidFlag = _Box2D2.b2Contact_e_nonSolidFlag
    e_slowFlag = _Box2D2.b2Contact_e_slowFlag
    e_islandFlag = _Box2D2.b2Contact_e_islandFlag
    e_toiFlag = _Box2D2.b2Contact_e_toiFlag
    def AddType(*args):
        """
        AddType(b2ContactCreateFcn createFcn, b2ContactDestroyFcn destroyFcn, 
            b2ShapeType type1, b2ShapeType type2)
        """
        return _Box2D2.b2Contact_AddType(*args)

    AddType = staticmethod(AddType)
    def InitializeRegisters(*args):
        """InitializeRegisters()"""
        return _Box2D2.b2Contact_InitializeRegisters(*args)

    InitializeRegisters = staticmethod(InitializeRegisters)
    def Create(*args):
        """Create(b2Shape shape1, b2Shape shape2, b2BlockAllocator allocator) -> b2Contact"""
        return _Box2D2.b2Contact_Create(*args)

    Create = staticmethod(Create)
    def Destroy(*args):
        """Destroy(b2Contact contact, b2BlockAllocator allocator)"""
        return _Box2D2.b2Contact_Destroy(*args)

    Destroy = staticmethod(Destroy)
    __swig_destroy__ = _Box2D2.delete_b2Contact
    def Update(*args):
        """Update(self, b2ContactListener listener)"""
        return _Box2D2.b2Contact_Update(*args)

    def Evaluate(*args):
        """Evaluate(self, b2ContactListener listener)"""
        return _Box2D2.b2Contact_Evaluate(*args)

    s_registers = _swig_property(_Box2D2.b2Contact_s_registers_get, _Box2D2.b2Contact_s_registers_set)
    s_initialized = _swig_property(_Box2D2.b2Contact_s_initialized_get, _Box2D2.b2Contact_s_initialized_set)
    m_flags = _swig_property(_Box2D2.b2Contact_m_flags_get, _Box2D2.b2Contact_m_flags_set)
    m_manifoldCount = _swig_property(_Box2D2.b2Contact_m_manifoldCount_get, _Box2D2.b2Contact_m_manifoldCount_set)
    m_prev = _swig_property(_Box2D2.b2Contact_m_prev_get, _Box2D2.b2Contact_m_prev_set)
    m_next = _swig_property(_Box2D2.b2Contact_m_next_get, _Box2D2.b2Contact_m_next_set)
    m_node1 = _swig_property(_Box2D2.b2Contact_m_node1_get, _Box2D2.b2Contact_m_node1_set)
    m_node2 = _swig_property(_Box2D2.b2Contact_m_node2_get, _Box2D2.b2Contact_m_node2_set)
    m_shape1 = _swig_property(_Box2D2.b2Contact_m_shape1_get, _Box2D2.b2Contact_m_shape1_set)
    m_shape2 = _swig_property(_Box2D2.b2Contact_m_shape2_get, _Box2D2.b2Contact_m_shape2_set)
    m_friction = _swig_property(_Box2D2.b2Contact_m_friction_get, _Box2D2.b2Contact_m_friction_set)
    m_restitution = _swig_property(_Box2D2.b2Contact_m_restitution_get, _Box2D2.b2Contact_m_restitution_set)
    m_toi = _swig_property(_Box2D2.b2Contact_m_toi_get, _Box2D2.b2Contact_m_toi_set)
b2Contact.GetManifolds = new_instancemethod(_Box2D2.b2Contact_GetManifolds,None,b2Contact)
b2Contact.GetManifoldCount = new_instancemethod(_Box2D2.b2Contact_GetManifoldCount,None,b2Contact)
b2Contact.IsSolid = new_instancemethod(_Box2D2.b2Contact_IsSolid,None,b2Contact)
b2Contact.GetNext = new_instancemethod(_Box2D2.b2Contact_GetNext,None,b2Contact)
b2Contact.GetShape1 = new_instancemethod(_Box2D2.b2Contact_GetShape1,None,b2Contact)
b2Contact.GetShape2 = new_instancemethod(_Box2D2.b2Contact_GetShape2,None,b2Contact)
b2Contact.Update = new_instancemethod(_Box2D2.b2Contact_Update,None,b2Contact)
b2Contact.Evaluate = new_instancemethod(_Box2D2.b2Contact_Evaluate,None,b2Contact)
b2Contact_swigregister = _Box2D2.b2Contact_swigregister
b2Contact_swigregister(b2Contact)

def b2Contact_AddType(*args):
  """
    b2Contact_AddType(b2ContactCreateFcn createFcn, b2ContactDestroyFcn destroyFcn, 
        b2ShapeType type1, b2ShapeType type2)
    """
  return _Box2D2.b2Contact_AddType(*args)

def b2Contact_InitializeRegisters(*args):
  """b2Contact_InitializeRegisters()"""
  return _Box2D2.b2Contact_InitializeRegisters(*args)

def b2Contact_Create(*args):
  """b2Contact_Create(b2Shape shape1, b2Shape shape2, b2BlockAllocator allocator) -> b2Contact"""
  return _Box2D2.b2Contact_Create(*args)

def b2Contact_Destroy(*args):
  """b2Contact_Destroy(b2Contact contact, b2BlockAllocator allocator)"""
  return _Box2D2.b2Contact_Destroy(*args)

class b2NullContact(b2Contact):
    """Proxy of C++ b2NullContact class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self) -> b2NullContact"""
        _Box2D2.b2NullContact_swiginit(self,_Box2D2.new_b2NullContact(*args))
    __swig_destroy__ = _Box2D2.delete_b2NullContact
b2NullContact_swigregister = _Box2D2.b2NullContact_swigregister
b2NullContact_swigregister(b2NullContact)

class b2ContactManager(b2PairCallback):
    """Proxy of C++ b2ContactManager class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self) -> b2ContactManager"""
        _Box2D2.b2ContactManager_swiginit(self,_Box2D2.new_b2ContactManager(*args))
    def Destroy(*args):
        """Destroy(self, b2Contact c)"""
        return _Box2D2.b2ContactManager_Destroy(*args)

    def Collide(*args):
        """Collide(self)"""
        return _Box2D2.b2ContactManager_Collide(*args)

    m_world = _swig_property(_Box2D2.b2ContactManager_m_world_get, _Box2D2.b2ContactManager_m_world_set)
    m_nullContact = _swig_property(_Box2D2.b2ContactManager_m_nullContact_get, _Box2D2.b2ContactManager_m_nullContact_set)
    m_destroyImmediate = _swig_property(_Box2D2.b2ContactManager_m_destroyImmediate_get, _Box2D2.b2ContactManager_m_destroyImmediate_set)
    __swig_destroy__ = _Box2D2.delete_b2ContactManager
b2ContactManager.Destroy = new_instancemethod(_Box2D2.b2ContactManager_Destroy,None,b2ContactManager)
b2ContactManager.Collide = new_instancemethod(_Box2D2.b2ContactManager_Collide,None,b2ContactManager)
b2ContactManager_swigregister = _Box2D2.b2ContactManager_swigregister
b2ContactManager_swigregister(b2ContactManager)

class b2TimeStep(object):
    """Proxy of C++ b2TimeStep class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    dt = _swig_property(_Box2D2.b2TimeStep_dt_get, _Box2D2.b2TimeStep_dt_set)
    inv_dt = _swig_property(_Box2D2.b2TimeStep_inv_dt_get, _Box2D2.b2TimeStep_inv_dt_set)
    dtRatio = _swig_property(_Box2D2.b2TimeStep_dtRatio_get, _Box2D2.b2TimeStep_dtRatio_set)
    maxIterations = _swig_property(_Box2D2.b2TimeStep_maxIterations_get, _Box2D2.b2TimeStep_maxIterations_set)
    warmStarting = _swig_property(_Box2D2.b2TimeStep_warmStarting_get, _Box2D2.b2TimeStep_warmStarting_set)
    positionCorrection = _swig_property(_Box2D2.b2TimeStep_positionCorrection_get, _Box2D2.b2TimeStep_positionCorrection_set)
    def __init__(self, *args): 
        """__init__(self) -> b2TimeStep"""
        _Box2D2.b2TimeStep_swiginit(self,_Box2D2.new_b2TimeStep(*args))
    __swig_destroy__ = _Box2D2.delete_b2TimeStep
b2TimeStep_swigregister = _Box2D2.b2TimeStep_swigregister
b2TimeStep_swigregister(b2TimeStep)

class b2World(object):
    """Proxy of C++ b2World class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, b2AABB worldAABB, b2Vec2 gravity, bool doSleep) -> b2World"""
        _Box2D2.b2World_swiginit(self,_Box2D2.new_b2World(*args))
    __swig_destroy__ = _Box2D2.delete_b2World
    def SetDestructionListener(*args):
        """SetDestructionListener(self, b2DestructionListener listener)"""
        return _Box2D2.b2World_SetDestructionListener(*args)

    def SetBoundaryListener(*args):
        """SetBoundaryListener(self, b2BoundaryListener listener)"""
        return _Box2D2.b2World_SetBoundaryListener(*args)

    def SetContactFilter(*args):
        """SetContactFilter(self, b2ContactFilter filter)"""
        return _Box2D2.b2World_SetContactFilter(*args)

    def SetContactListener(*args):
        """SetContactListener(self, b2ContactListener listener)"""
        return _Box2D2.b2World_SetContactListener(*args)

    def SetDebugDraw(*args):
        """SetDebugDraw(self, b2DebugDraw debugDraw)"""
        return _Box2D2.b2World_SetDebugDraw(*args)

    def CreateBody(*args):
        """CreateBody(self, b2BodyDef def) -> b2Body"""
        return _Box2D2.b2World_CreateBody(*args)

    def DestroyBody(*args):
        """DestroyBody(self, b2Body body)"""
        return _Box2D2.b2World_DestroyBody(*args)

    def CreateJoint(*args):
        """CreateJoint(self, b2JointDef def) -> b2Joint"""
        return _Box2D2.b2World_CreateJoint(*args)

    def DestroyJoint(*args):
        """DestroyJoint(self, b2Joint joint)"""
        return _Box2D2.b2World_DestroyJoint(*args)

    def GetGroundBody(*args):
        """GetGroundBody(self) -> b2Body"""
        return _Box2D2.b2World_GetGroundBody(*args)

    def Step(*args):
        """Step(self, float32 timeStep, int32 iterations)"""
        return _Box2D2.b2World_Step(*args)

    def GetBodyList(*args):
        """GetBodyList(self) -> b2Body"""
        return _Box2D2.b2World_GetBodyList(*args)

    def GetJointList(*args):
        """GetJointList(self) -> b2Joint"""
        return _Box2D2.b2World_GetJointList(*args)

    def Refilter(*args):
        """Refilter(self, b2Shape shape)"""
        return _Box2D2.b2World_Refilter(*args)

    def SetWarmStarting(*args):
        """SetWarmStarting(self, bool flag)"""
        return _Box2D2.b2World_SetWarmStarting(*args)

    def SetPositionCorrection(*args):
        """SetPositionCorrection(self, bool flag)"""
        return _Box2D2.b2World_SetPositionCorrection(*args)

    def SetContinuousPhysics(*args):
        """SetContinuousPhysics(self, bool flag)"""
        return _Box2D2.b2World_SetContinuousPhysics(*args)

    def Validate(*args):
        """Validate(self)"""
        return _Box2D2.b2World_Validate(*args)

    def GetProxyCount(*args):
        """GetProxyCount(self) -> int32"""
        return _Box2D2.b2World_GetProxyCount(*args)

    def GetPairCount(*args):
        """GetPairCount(self) -> int32"""
        return _Box2D2.b2World_GetPairCount(*args)

    def GetBodyCount(*args):
        """GetBodyCount(self) -> int32"""
        return _Box2D2.b2World_GetBodyCount(*args)

    def GetJointCount(*args):
        """GetJointCount(self) -> int32"""
        return _Box2D2.b2World_GetJointCount(*args)

    def GetContactCount(*args):
        """GetContactCount(self) -> int32"""
        return _Box2D2.b2World_GetContactCount(*args)

    def SetGravity(*args):
        """SetGravity(self, b2Vec2 gravity)"""
        return _Box2D2.b2World_SetGravity(*args)

    def Query(*args):
        """
        Query(self, b2AABB aabb, b2Shape shapes, int32 maxCount) -> int32
        Query(self, b2AABB aabb, uint32 maxCount) -> PyObject
        """
        return _Box2D2.b2World_Query(*args)

b2World.SetDestructionListener = new_instancemethod(_Box2D2.b2World_SetDestructionListener,None,b2World)
b2World.SetBoundaryListener = new_instancemethod(_Box2D2.b2World_SetBoundaryListener,None,b2World)
b2World.SetContactFilter = new_instancemethod(_Box2D2.b2World_SetContactFilter,None,b2World)
b2World.SetContactListener = new_instancemethod(_Box2D2.b2World_SetContactListener,None,b2World)
b2World.SetDebugDraw = new_instancemethod(_Box2D2.b2World_SetDebugDraw,None,b2World)
b2World.CreateBody = new_instancemethod(_Box2D2.b2World_CreateBody,None,b2World)
b2World.DestroyBody = new_instancemethod(_Box2D2.b2World_DestroyBody,None,b2World)
b2World.CreateJoint = new_instancemethod(_Box2D2.b2World_CreateJoint,None,b2World)
b2World.DestroyJoint = new_instancemethod(_Box2D2.b2World_DestroyJoint,None,b2World)
b2World.GetGroundBody = new_instancemethod(_Box2D2.b2World_GetGroundBody,None,b2World)
b2World.Step = new_instancemethod(_Box2D2.b2World_Step,None,b2World)
b2World.GetBodyList = new_instancemethod(_Box2D2.b2World_GetBodyList,None,b2World)
b2World.GetJointList = new_instancemethod(_Box2D2.b2World_GetJointList,None,b2World)
b2World.Refilter = new_instancemethod(_Box2D2.b2World_Refilter,None,b2World)
b2World.SetWarmStarting = new_instancemethod(_Box2D2.b2World_SetWarmStarting,None,b2World)
b2World.SetPositionCorrection = new_instancemethod(_Box2D2.b2World_SetPositionCorrection,None,b2World)
b2World.SetContinuousPhysics = new_instancemethod(_Box2D2.b2World_SetContinuousPhysics,None,b2World)
b2World.Validate = new_instancemethod(_Box2D2.b2World_Validate,None,b2World)
b2World.GetProxyCount = new_instancemethod(_Box2D2.b2World_GetProxyCount,None,b2World)
b2World.GetPairCount = new_instancemethod(_Box2D2.b2World_GetPairCount,None,b2World)
b2World.GetBodyCount = new_instancemethod(_Box2D2.b2World_GetBodyCount,None,b2World)
b2World.GetJointCount = new_instancemethod(_Box2D2.b2World_GetJointCount,None,b2World)
b2World.GetContactCount = new_instancemethod(_Box2D2.b2World_GetContactCount,None,b2World)
b2World.SetGravity = new_instancemethod(_Box2D2.b2World_SetGravity,None,b2World)
b2World.Query = new_instancemethod(_Box2D2.b2World_Query,None,b2World)
b2World_swigregister = _Box2D2.b2World_swigregister
b2World_swigregister(b2World)

class b2BodyDef(object):
    """Proxy of C++ b2BodyDef class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self) -> b2BodyDef"""
        _Box2D2.b2BodyDef_swiginit(self,_Box2D2.new_b2BodyDef(*args))
    massData = _swig_property(_Box2D2.b2BodyDef_massData_get, _Box2D2.b2BodyDef_massData_set)
    userData = _swig_property(_Box2D2.b2BodyDef_userData_get, _Box2D2.b2BodyDef_userData_set)
    position = _swig_property(_Box2D2.b2BodyDef_position_get, _Box2D2.b2BodyDef_position_set)
    angle = _swig_property(_Box2D2.b2BodyDef_angle_get, _Box2D2.b2BodyDef_angle_set)
    linearDamping = _swig_property(_Box2D2.b2BodyDef_linearDamping_get, _Box2D2.b2BodyDef_linearDamping_set)
    angularDamping = _swig_property(_Box2D2.b2BodyDef_angularDamping_get, _Box2D2.b2BodyDef_angularDamping_set)
    allowSleep = _swig_property(_Box2D2.b2BodyDef_allowSleep_get, _Box2D2.b2BodyDef_allowSleep_set)
    isSleeping = _swig_property(_Box2D2.b2BodyDef_isSleeping_get, _Box2D2.b2BodyDef_isSleeping_set)
    fixedRotation = _swig_property(_Box2D2.b2BodyDef_fixedRotation_get, _Box2D2.b2BodyDef_fixedRotation_set)
    isBullet = _swig_property(_Box2D2.b2BodyDef_isBullet_get, _Box2D2.b2BodyDef_isBullet_set)
    __swig_destroy__ = _Box2D2.delete_b2BodyDef
b2BodyDef_swigregister = _Box2D2.b2BodyDef_swigregister
b2BodyDef_swigregister(b2BodyDef)

class b2Body(object):
    """Proxy of C++ b2Body class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    def CreateShape(*args):
        """CreateShape(self, b2ShapeDef shapeDef) -> b2Shape"""
        return _Box2D2.b2Body_CreateShape(*args)

    def DestroyShape(*args):
        """DestroyShape(self, b2Shape shape)"""
        return _Box2D2.b2Body_DestroyShape(*args)

    def SetMass(*args):
        """SetMass(self, b2MassData massData)"""
        return _Box2D2.b2Body_SetMass(*args)

    def SetMassFromShapes(*args):
        """SetMassFromShapes(self)"""
        return _Box2D2.b2Body_SetMassFromShapes(*args)

    def SetXForm(*args):
        """SetXForm(self, b2Vec2 position, float32 angle) -> bool"""
        return _Box2D2.b2Body_SetXForm(*args)

    def GetXForm(*args):
        """GetXForm(self) -> b2XForm"""
        return _Box2D2.b2Body_GetXForm(*args)

    def GetPosition(*args):
        """GetPosition(self) -> b2Vec2"""
        return _Box2D2.b2Body_GetPosition(*args)

    def GetAngle(*args):
        """GetAngle(self) -> float32"""
        return _Box2D2.b2Body_GetAngle(*args)

    def GetWorldCenter(*args):
        """GetWorldCenter(self) -> b2Vec2"""
        return _Box2D2.b2Body_GetWorldCenter(*args)

    def GetLocalCenter(*args):
        """GetLocalCenter(self) -> b2Vec2"""
        return _Box2D2.b2Body_GetLocalCenter(*args)

    def SetLinearVelocity(*args):
        """SetLinearVelocity(self, b2Vec2 v)"""
        return _Box2D2.b2Body_SetLinearVelocity(*args)

    def GetLinearVelocity(*args):
        """GetLinearVelocity(self) -> b2Vec2"""
        return _Box2D2.b2Body_GetLinearVelocity(*args)

    def SetAngularVelocity(*args):
        """SetAngularVelocity(self, float32 omega)"""
        return _Box2D2.b2Body_SetAngularVelocity(*args)

    def GetAngularVelocity(*args):
        """GetAngularVelocity(self) -> float32"""
        return _Box2D2.b2Body_GetAngularVelocity(*args)

    def ApplyForce(*args):
        """ApplyForce(self, b2Vec2 force, b2Vec2 point)"""
        return _Box2D2.b2Body_ApplyForce(*args)

    def ApplyTorque(*args):
        """ApplyTorque(self, float32 torque)"""
        return _Box2D2.b2Body_ApplyTorque(*args)

    def ApplyImpulse(*args):
        """ApplyImpulse(self, b2Vec2 impulse, b2Vec2 point)"""
        return _Box2D2.b2Body_ApplyImpulse(*args)

    def GetMass(*args):
        """GetMass(self) -> float32"""
        return _Box2D2.b2Body_GetMass(*args)

    def GetInertia(*args):
        """GetInertia(self) -> float32"""
        return _Box2D2.b2Body_GetInertia(*args)

    def GetWorldPoint(*args):
        """GetWorldPoint(self, b2Vec2 localPoint) -> b2Vec2"""
        return _Box2D2.b2Body_GetWorldPoint(*args)

    def GetWorldVector(*args):
        """GetWorldVector(self, b2Vec2 localVector) -> b2Vec2"""
        return _Box2D2.b2Body_GetWorldVector(*args)

    def GetLocalPoint(*args):
        """GetLocalPoint(self, b2Vec2 worldPoint) -> b2Vec2"""
        return _Box2D2.b2Body_GetLocalPoint(*args)

    def GetLocalVector(*args):
        """GetLocalVector(self, b2Vec2 worldVector) -> b2Vec2"""
        return _Box2D2.b2Body_GetLocalVector(*args)

    def GetLinearVelocityFromWorldPoint(*args):
        """GetLinearVelocityFromWorldPoint(self, b2Vec2 worldPoint) -> b2Vec2"""
        return _Box2D2.b2Body_GetLinearVelocityFromWorldPoint(*args)

    def GetLinearVelocityFromLocalPoint(*args):
        """GetLinearVelocityFromLocalPoint(self, b2Vec2 localPoint) -> b2Vec2"""
        return _Box2D2.b2Body_GetLinearVelocityFromLocalPoint(*args)

    def IsBullet(*args):
        """IsBullet(self) -> bool"""
        return _Box2D2.b2Body_IsBullet(*args)

    def SetBullet(*args):
        """SetBullet(self, bool flag)"""
        return _Box2D2.b2Body_SetBullet(*args)

    def IsStatic(*args):
        """IsStatic(self) -> bool"""
        return _Box2D2.b2Body_IsStatic(*args)

    def IsDynamic(*args):
        """IsDynamic(self) -> bool"""
        return _Box2D2.b2Body_IsDynamic(*args)

    def IsFrozen(*args):
        """IsFrozen(self) -> bool"""
        return _Box2D2.b2Body_IsFrozen(*args)

    def IsSleeping(*args):
        """IsSleeping(self) -> bool"""
        return _Box2D2.b2Body_IsSleeping(*args)

    def AllowSleeping(*args):
        """AllowSleeping(self, bool flag)"""
        return _Box2D2.b2Body_AllowSleeping(*args)

    def WakeUp(*args):
        """WakeUp(self)"""
        return _Box2D2.b2Body_WakeUp(*args)

    def PutToSleep(*args):
        """PutToSleep(self)"""
        return _Box2D2.b2Body_PutToSleep(*args)

    def GetShapeList(*args):
        """GetShapeList(self) -> b2Shape"""
        return _Box2D2.b2Body_GetShapeList(*args)

    def GetJointList(*args):
        """GetJointList(self) -> b2JointEdge"""
        return _Box2D2.b2Body_GetJointList(*args)

    def GetNext(*args):
        """GetNext(self) -> b2Body"""
        return _Box2D2.b2Body_GetNext(*args)

    def GetUserData(self): # override the C++ version as it does not work. 
        """Get the specified userData (m_userData)"""
        return self.pyGetUserData()


    def SetUserData(*args):
        """SetUserData(self, void data)"""
        return _Box2D2.b2Body_SetUserData(*args)

    def GetWorld(*args):
        """GetWorld(self) -> b2World"""
        return _Box2D2.b2Body_GetWorld(*args)

    def __repr__(self):
        return "b2Body(Position: %s)" % (self.GetPosition())

    def pyGetUserData(*args):
        """pyGetUserData(self) -> PyObject"""
        return _Box2D2.b2Body_pyGetUserData(*args)

b2Body.CreateShape = new_instancemethod(_Box2D2.b2Body_CreateShape,None,b2Body)
b2Body.DestroyShape = new_instancemethod(_Box2D2.b2Body_DestroyShape,None,b2Body)
b2Body.SetMass = new_instancemethod(_Box2D2.b2Body_SetMass,None,b2Body)
b2Body.SetMassFromShapes = new_instancemethod(_Box2D2.b2Body_SetMassFromShapes,None,b2Body)
b2Body.SetXForm = new_instancemethod(_Box2D2.b2Body_SetXForm,None,b2Body)
b2Body.GetXForm = new_instancemethod(_Box2D2.b2Body_GetXForm,None,b2Body)
b2Body.GetPosition = new_instancemethod(_Box2D2.b2Body_GetPosition,None,b2Body)
b2Body.GetAngle = new_instancemethod(_Box2D2.b2Body_GetAngle,None,b2Body)
b2Body.GetWorldCenter = new_instancemethod(_Box2D2.b2Body_GetWorldCenter,None,b2Body)
b2Body.GetLocalCenter = new_instancemethod(_Box2D2.b2Body_GetLocalCenter,None,b2Body)
b2Body.SetLinearVelocity = new_instancemethod(_Box2D2.b2Body_SetLinearVelocity,None,b2Body)
b2Body.GetLinearVelocity = new_instancemethod(_Box2D2.b2Body_GetLinearVelocity,None,b2Body)
b2Body.SetAngularVelocity = new_instancemethod(_Box2D2.b2Body_SetAngularVelocity,None,b2Body)
b2Body.GetAngularVelocity = new_instancemethod(_Box2D2.b2Body_GetAngularVelocity,None,b2Body)
b2Body.ApplyForce = new_instancemethod(_Box2D2.b2Body_ApplyForce,None,b2Body)
b2Body.ApplyTorque = new_instancemethod(_Box2D2.b2Body_ApplyTorque,None,b2Body)
b2Body.ApplyImpulse = new_instancemethod(_Box2D2.b2Body_ApplyImpulse,None,b2Body)
b2Body.GetMass = new_instancemethod(_Box2D2.b2Body_GetMass,None,b2Body)
b2Body.GetInertia = new_instancemethod(_Box2D2.b2Body_GetInertia,None,b2Body)
b2Body.GetWorldPoint = new_instancemethod(_Box2D2.b2Body_GetWorldPoint,None,b2Body)
b2Body.GetWorldVector = new_instancemethod(_Box2D2.b2Body_GetWorldVector,None,b2Body)
b2Body.GetLocalPoint = new_instancemethod(_Box2D2.b2Body_GetLocalPoint,None,b2Body)
b2Body.GetLocalVector = new_instancemethod(_Box2D2.b2Body_GetLocalVector,None,b2Body)
b2Body.GetLinearVelocityFromWorldPoint = new_instancemethod(_Box2D2.b2Body_GetLinearVelocityFromWorldPoint,None,b2Body)
b2Body.GetLinearVelocityFromLocalPoint = new_instancemethod(_Box2D2.b2Body_GetLinearVelocityFromLocalPoint,None,b2Body)
b2Body.IsBullet = new_instancemethod(_Box2D2.b2Body_IsBullet,None,b2Body)
b2Body.SetBullet = new_instancemethod(_Box2D2.b2Body_SetBullet,None,b2Body)
b2Body.IsStatic = new_instancemethod(_Box2D2.b2Body_IsStatic,None,b2Body)
b2Body.IsDynamic = new_instancemethod(_Box2D2.b2Body_IsDynamic,None,b2Body)
b2Body.IsFrozen = new_instancemethod(_Box2D2.b2Body_IsFrozen,None,b2Body)
b2Body.IsSleeping = new_instancemethod(_Box2D2.b2Body_IsSleeping,None,b2Body)
b2Body.AllowSleeping = new_instancemethod(_Box2D2.b2Body_AllowSleeping,None,b2Body)
b2Body.WakeUp = new_instancemethod(_Box2D2.b2Body_WakeUp,None,b2Body)
b2Body.PutToSleep = new_instancemethod(_Box2D2.b2Body_PutToSleep,None,b2Body)
b2Body.GetShapeList = new_instancemethod(_Box2D2.b2Body_GetShapeList,None,b2Body)
b2Body.GetJointList = new_instancemethod(_Box2D2.b2Body_GetJointList,None,b2Body)
b2Body.GetNext = new_instancemethod(_Box2D2.b2Body_GetNext,None,b2Body)
b2Body.SetUserData = new_instancemethod(_Box2D2.b2Body_SetUserData,None,b2Body)
b2Body.GetWorld = new_instancemethod(_Box2D2.b2Body_GetWorld,None,b2Body)
b2Body.pyGetUserData = new_instancemethod(_Box2D2.b2Body_pyGetUserData,None,b2Body)
b2Body_swigregister = _Box2D2.b2Body_swigregister
b2Body_swigregister(b2Body)

class b2DistanceJointDef(b2JointDef):
    """Proxy of C++ b2DistanceJointDef class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self) -> b2DistanceJointDef"""
        _Box2D2.b2DistanceJointDef_swiginit(self,_Box2D2.new_b2DistanceJointDef(*args))
    def Initialize(*args):
        """Initialize(self, b2Body body1, b2Body body2, b2Vec2 anchor1, b2Vec2 anchor2)"""
        return _Box2D2.b2DistanceJointDef_Initialize(*args)

    localAnchor1 = _swig_property(_Box2D2.b2DistanceJointDef_localAnchor1_get, _Box2D2.b2DistanceJointDef_localAnchor1_set)
    localAnchor2 = _swig_property(_Box2D2.b2DistanceJointDef_localAnchor2_get, _Box2D2.b2DistanceJointDef_localAnchor2_set)
    length = _swig_property(_Box2D2.b2DistanceJointDef_length_get, _Box2D2.b2DistanceJointDef_length_set)
    frequencyHz = _swig_property(_Box2D2.b2DistanceJointDef_frequencyHz_get, _Box2D2.b2DistanceJointDef_frequencyHz_set)
    dampingRatio = _swig_property(_Box2D2.b2DistanceJointDef_dampingRatio_get, _Box2D2.b2DistanceJointDef_dampingRatio_set)
    __swig_destroy__ = _Box2D2.delete_b2DistanceJointDef
b2DistanceJointDef.Initialize = new_instancemethod(_Box2D2.b2DistanceJointDef_Initialize,None,b2DistanceJointDef)
b2DistanceJointDef_swigregister = _Box2D2.b2DistanceJointDef_swigregister
b2DistanceJointDef_swigregister(b2DistanceJointDef)

class b2DistanceJoint(b2Joint):
    """Proxy of C++ b2DistanceJoint class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, b2DistanceJointDef data) -> b2DistanceJoint"""
        _Box2D2.b2DistanceJoint_swiginit(self,_Box2D2.new_b2DistanceJoint(*args))
    def InitVelocityConstraints(*args):
        """InitVelocityConstraints(self, b2TimeStep step)"""
        return _Box2D2.b2DistanceJoint_InitVelocityConstraints(*args)

    def SolveVelocityConstraints(*args):
        """SolveVelocityConstraints(self, b2TimeStep step)"""
        return _Box2D2.b2DistanceJoint_SolveVelocityConstraints(*args)

    def SolvePositionConstraints(*args):
        """SolvePositionConstraints(self) -> bool"""
        return _Box2D2.b2DistanceJoint_SolvePositionConstraints(*args)

    m_localAnchor1 = _swig_property(_Box2D2.b2DistanceJoint_m_localAnchor1_get, _Box2D2.b2DistanceJoint_m_localAnchor1_set)
    m_localAnchor2 = _swig_property(_Box2D2.b2DistanceJoint_m_localAnchor2_get, _Box2D2.b2DistanceJoint_m_localAnchor2_set)
    m_u = _swig_property(_Box2D2.b2DistanceJoint_m_u_get, _Box2D2.b2DistanceJoint_m_u_set)
    m_frequencyHz = _swig_property(_Box2D2.b2DistanceJoint_m_frequencyHz_get, _Box2D2.b2DistanceJoint_m_frequencyHz_set)
    m_dampingRatio = _swig_property(_Box2D2.b2DistanceJoint_m_dampingRatio_get, _Box2D2.b2DistanceJoint_m_dampingRatio_set)
    m_gamma = _swig_property(_Box2D2.b2DistanceJoint_m_gamma_get, _Box2D2.b2DistanceJoint_m_gamma_set)
    m_bias = _swig_property(_Box2D2.b2DistanceJoint_m_bias_get, _Box2D2.b2DistanceJoint_m_bias_set)
    m_impulse = _swig_property(_Box2D2.b2DistanceJoint_m_impulse_get, _Box2D2.b2DistanceJoint_m_impulse_set)
    m_mass = _swig_property(_Box2D2.b2DistanceJoint_m_mass_get, _Box2D2.b2DistanceJoint_m_mass_set)
    m_length = _swig_property(_Box2D2.b2DistanceJoint_m_length_get, _Box2D2.b2DistanceJoint_m_length_set)
    def __repr__(self):
        return b2JointInfo(self)

    __swig_destroy__ = _Box2D2.delete_b2DistanceJoint
b2DistanceJoint.InitVelocityConstraints = new_instancemethod(_Box2D2.b2DistanceJoint_InitVelocityConstraints,None,b2DistanceJoint)
b2DistanceJoint.SolveVelocityConstraints = new_instancemethod(_Box2D2.b2DistanceJoint_SolveVelocityConstraints,None,b2DistanceJoint)
b2DistanceJoint.SolvePositionConstraints = new_instancemethod(_Box2D2.b2DistanceJoint_SolvePositionConstraints,None,b2DistanceJoint)
b2DistanceJoint_swigregister = _Box2D2.b2DistanceJoint_swigregister
b2DistanceJoint_swigregister(b2DistanceJoint)

class b2MouseJointDef(b2JointDef):
    """Proxy of C++ b2MouseJointDef class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self) -> b2MouseJointDef"""
        _Box2D2.b2MouseJointDef_swiginit(self,_Box2D2.new_b2MouseJointDef(*args))
    target = _swig_property(_Box2D2.b2MouseJointDef_target_get, _Box2D2.b2MouseJointDef_target_set)
    maxForce = _swig_property(_Box2D2.b2MouseJointDef_maxForce_get, _Box2D2.b2MouseJointDef_maxForce_set)
    frequencyHz = _swig_property(_Box2D2.b2MouseJointDef_frequencyHz_get, _Box2D2.b2MouseJointDef_frequencyHz_set)
    dampingRatio = _swig_property(_Box2D2.b2MouseJointDef_dampingRatio_get, _Box2D2.b2MouseJointDef_dampingRatio_set)
    timeStep = _swig_property(_Box2D2.b2MouseJointDef_timeStep_get, _Box2D2.b2MouseJointDef_timeStep_set)
    __swig_destroy__ = _Box2D2.delete_b2MouseJointDef
b2MouseJointDef_swigregister = _Box2D2.b2MouseJointDef_swigregister
b2MouseJointDef_swigregister(b2MouseJointDef)

class b2MouseJoint(b2Joint):
    """Proxy of C++ b2MouseJoint class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def SetTarget(*args):
        """SetTarget(self, b2Vec2 target)"""
        return _Box2D2.b2MouseJoint_SetTarget(*args)

    def __init__(self, *args): 
        """__init__(self, b2MouseJointDef def) -> b2MouseJoint"""
        _Box2D2.b2MouseJoint_swiginit(self,_Box2D2.new_b2MouseJoint(*args))
    def InitVelocityConstraints(*args):
        """InitVelocityConstraints(self, b2TimeStep step)"""
        return _Box2D2.b2MouseJoint_InitVelocityConstraints(*args)

    def SolveVelocityConstraints(*args):
        """SolveVelocityConstraints(self, b2TimeStep step)"""
        return _Box2D2.b2MouseJoint_SolveVelocityConstraints(*args)

    def SolvePositionConstraints(*args):
        """SolvePositionConstraints(self) -> bool"""
        return _Box2D2.b2MouseJoint_SolvePositionConstraints(*args)

    m_localAnchor = _swig_property(_Box2D2.b2MouseJoint_m_localAnchor_get, _Box2D2.b2MouseJoint_m_localAnchor_set)
    m_target = _swig_property(_Box2D2.b2MouseJoint_m_target_get, _Box2D2.b2MouseJoint_m_target_set)
    m_impulse = _swig_property(_Box2D2.b2MouseJoint_m_impulse_get, _Box2D2.b2MouseJoint_m_impulse_set)
    m_mass = _swig_property(_Box2D2.b2MouseJoint_m_mass_get, _Box2D2.b2MouseJoint_m_mass_set)
    m_C = _swig_property(_Box2D2.b2MouseJoint_m_C_get, _Box2D2.b2MouseJoint_m_C_set)
    m_maxForce = _swig_property(_Box2D2.b2MouseJoint_m_maxForce_get, _Box2D2.b2MouseJoint_m_maxForce_set)
    m_beta = _swig_property(_Box2D2.b2MouseJoint_m_beta_get, _Box2D2.b2MouseJoint_m_beta_set)
    m_gamma = _swig_property(_Box2D2.b2MouseJoint_m_gamma_get, _Box2D2.b2MouseJoint_m_gamma_set)
    def __repr__(self):
        return b2JointInfo(self)

    __swig_destroy__ = _Box2D2.delete_b2MouseJoint
b2MouseJoint.SetTarget = new_instancemethod(_Box2D2.b2MouseJoint_SetTarget,None,b2MouseJoint)
b2MouseJoint.InitVelocityConstraints = new_instancemethod(_Box2D2.b2MouseJoint_InitVelocityConstraints,None,b2MouseJoint)
b2MouseJoint.SolveVelocityConstraints = new_instancemethod(_Box2D2.b2MouseJoint_SolveVelocityConstraints,None,b2MouseJoint)
b2MouseJoint.SolvePositionConstraints = new_instancemethod(_Box2D2.b2MouseJoint_SolvePositionConstraints,None,b2MouseJoint)
b2MouseJoint_swigregister = _Box2D2.b2MouseJoint_swigregister
b2MouseJoint_swigregister(b2MouseJoint)

class b2PrismaticJointDef(b2JointDef):
    """Proxy of C++ b2PrismaticJointDef class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self) -> b2PrismaticJointDef"""
        _Box2D2.b2PrismaticJointDef_swiginit(self,_Box2D2.new_b2PrismaticJointDef(*args))
    def Initialize(*args):
        """Initialize(self, b2Body body1, b2Body body2, b2Vec2 anchor, b2Vec2 axis)"""
        return _Box2D2.b2PrismaticJointDef_Initialize(*args)

    localAnchor1 = _swig_property(_Box2D2.b2PrismaticJointDef_localAnchor1_get, _Box2D2.b2PrismaticJointDef_localAnchor1_set)
    localAnchor2 = _swig_property(_Box2D2.b2PrismaticJointDef_localAnchor2_get, _Box2D2.b2PrismaticJointDef_localAnchor2_set)
    localAxis1 = _swig_property(_Box2D2.b2PrismaticJointDef_localAxis1_get, _Box2D2.b2PrismaticJointDef_localAxis1_set)
    referenceAngle = _swig_property(_Box2D2.b2PrismaticJointDef_referenceAngle_get, _Box2D2.b2PrismaticJointDef_referenceAngle_set)
    enableLimit = _swig_property(_Box2D2.b2PrismaticJointDef_enableLimit_get, _Box2D2.b2PrismaticJointDef_enableLimit_set)
    lowerTranslation = _swig_property(_Box2D2.b2PrismaticJointDef_lowerTranslation_get, _Box2D2.b2PrismaticJointDef_lowerTranslation_set)
    upperTranslation = _swig_property(_Box2D2.b2PrismaticJointDef_upperTranslation_get, _Box2D2.b2PrismaticJointDef_upperTranslation_set)
    enableMotor = _swig_property(_Box2D2.b2PrismaticJointDef_enableMotor_get, _Box2D2.b2PrismaticJointDef_enableMotor_set)
    maxMotorForce = _swig_property(_Box2D2.b2PrismaticJointDef_maxMotorForce_get, _Box2D2.b2PrismaticJointDef_maxMotorForce_set)
    motorSpeed = _swig_property(_Box2D2.b2PrismaticJointDef_motorSpeed_get, _Box2D2.b2PrismaticJointDef_motorSpeed_set)
    __swig_destroy__ = _Box2D2.delete_b2PrismaticJointDef
b2PrismaticJointDef.Initialize = new_instancemethod(_Box2D2.b2PrismaticJointDef_Initialize,None,b2PrismaticJointDef)
b2PrismaticJointDef_swigregister = _Box2D2.b2PrismaticJointDef_swigregister
b2PrismaticJointDef_swigregister(b2PrismaticJointDef)

class b2PrismaticJoint(b2Joint):
    """Proxy of C++ b2PrismaticJoint class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def GetJointTranslation(*args):
        """GetJointTranslation(self) -> float32"""
        return _Box2D2.b2PrismaticJoint_GetJointTranslation(*args)

    def GetJointSpeed(*args):
        """GetJointSpeed(self) -> float32"""
        return _Box2D2.b2PrismaticJoint_GetJointSpeed(*args)

    def IsLimitEnabled(*args):
        """IsLimitEnabled(self) -> bool"""
        return _Box2D2.b2PrismaticJoint_IsLimitEnabled(*args)

    def EnableLimit(*args):
        """EnableLimit(self, bool flag)"""
        return _Box2D2.b2PrismaticJoint_EnableLimit(*args)

    def GetLowerLimit(*args):
        """GetLowerLimit(self) -> float32"""
        return _Box2D2.b2PrismaticJoint_GetLowerLimit(*args)

    def GetUpperLimit(*args):
        """GetUpperLimit(self) -> float32"""
        return _Box2D2.b2PrismaticJoint_GetUpperLimit(*args)

    def SetLimits(*args):
        """SetLimits(self, float32 lower, float32 upper)"""
        return _Box2D2.b2PrismaticJoint_SetLimits(*args)

    def IsMotorEnabled(*args):
        """IsMotorEnabled(self) -> bool"""
        return _Box2D2.b2PrismaticJoint_IsMotorEnabled(*args)

    def EnableMotor(*args):
        """EnableMotor(self, bool flag)"""
        return _Box2D2.b2PrismaticJoint_EnableMotor(*args)

    def SetMotorSpeed(*args):
        """SetMotorSpeed(self, float32 speed)"""
        return _Box2D2.b2PrismaticJoint_SetMotorSpeed(*args)

    def GetMotorSpeed(*args):
        """GetMotorSpeed(self) -> float32"""
        return _Box2D2.b2PrismaticJoint_GetMotorSpeed(*args)

    def SetMaxMotorForce(*args):
        """SetMaxMotorForce(self, float32 force)"""
        return _Box2D2.b2PrismaticJoint_SetMaxMotorForce(*args)

    def GetMotorForce(*args):
        """GetMotorForce(self) -> float32"""
        return _Box2D2.b2PrismaticJoint_GetMotorForce(*args)

    def __init__(self, *args): 
        """__init__(self, b2PrismaticJointDef def) -> b2PrismaticJoint"""
        _Box2D2.b2PrismaticJoint_swiginit(self,_Box2D2.new_b2PrismaticJoint(*args))
    def InitVelocityConstraints(*args):
        """InitVelocityConstraints(self, b2TimeStep step)"""
        return _Box2D2.b2PrismaticJoint_InitVelocityConstraints(*args)

    def SolveVelocityConstraints(*args):
        """SolveVelocityConstraints(self, b2TimeStep step)"""
        return _Box2D2.b2PrismaticJoint_SolveVelocityConstraints(*args)

    def SolvePositionConstraints(*args):
        """SolvePositionConstraints(self) -> bool"""
        return _Box2D2.b2PrismaticJoint_SolvePositionConstraints(*args)

    m_localAnchor1 = _swig_property(_Box2D2.b2PrismaticJoint_m_localAnchor1_get, _Box2D2.b2PrismaticJoint_m_localAnchor1_set)
    m_localAnchor2 = _swig_property(_Box2D2.b2PrismaticJoint_m_localAnchor2_get, _Box2D2.b2PrismaticJoint_m_localAnchor2_set)
    m_localXAxis1 = _swig_property(_Box2D2.b2PrismaticJoint_m_localXAxis1_get, _Box2D2.b2PrismaticJoint_m_localXAxis1_set)
    m_localYAxis1 = _swig_property(_Box2D2.b2PrismaticJoint_m_localYAxis1_get, _Box2D2.b2PrismaticJoint_m_localYAxis1_set)
    m_refAngle = _swig_property(_Box2D2.b2PrismaticJoint_m_refAngle_get, _Box2D2.b2PrismaticJoint_m_refAngle_set)
    m_linearJacobian = _swig_property(_Box2D2.b2PrismaticJoint_m_linearJacobian_get, _Box2D2.b2PrismaticJoint_m_linearJacobian_set)
    m_linearMass = _swig_property(_Box2D2.b2PrismaticJoint_m_linearMass_get, _Box2D2.b2PrismaticJoint_m_linearMass_set)
    m_force = _swig_property(_Box2D2.b2PrismaticJoint_m_force_get, _Box2D2.b2PrismaticJoint_m_force_set)
    m_angularMass = _swig_property(_Box2D2.b2PrismaticJoint_m_angularMass_get, _Box2D2.b2PrismaticJoint_m_angularMass_set)
    m_torque = _swig_property(_Box2D2.b2PrismaticJoint_m_torque_get, _Box2D2.b2PrismaticJoint_m_torque_set)
    m_motorJacobian = _swig_property(_Box2D2.b2PrismaticJoint_m_motorJacobian_get, _Box2D2.b2PrismaticJoint_m_motorJacobian_set)
    m_motorMass = _swig_property(_Box2D2.b2PrismaticJoint_m_motorMass_get, _Box2D2.b2PrismaticJoint_m_motorMass_set)
    m_motorForce = _swig_property(_Box2D2.b2PrismaticJoint_m_motorForce_get, _Box2D2.b2PrismaticJoint_m_motorForce_set)
    m_limitForce = _swig_property(_Box2D2.b2PrismaticJoint_m_limitForce_get, _Box2D2.b2PrismaticJoint_m_limitForce_set)
    m_limitPositionImpulse = _swig_property(_Box2D2.b2PrismaticJoint_m_limitPositionImpulse_get, _Box2D2.b2PrismaticJoint_m_limitPositionImpulse_set)
    m_lowerTranslation = _swig_property(_Box2D2.b2PrismaticJoint_m_lowerTranslation_get, _Box2D2.b2PrismaticJoint_m_lowerTranslation_set)
    m_upperTranslation = _swig_property(_Box2D2.b2PrismaticJoint_m_upperTranslation_get, _Box2D2.b2PrismaticJoint_m_upperTranslation_set)
    m_maxMotorForce = _swig_property(_Box2D2.b2PrismaticJoint_m_maxMotorForce_get, _Box2D2.b2PrismaticJoint_m_maxMotorForce_set)
    m_motorSpeed = _swig_property(_Box2D2.b2PrismaticJoint_m_motorSpeed_get, _Box2D2.b2PrismaticJoint_m_motorSpeed_set)
    m_enableLimit = _swig_property(_Box2D2.b2PrismaticJoint_m_enableLimit_get, _Box2D2.b2PrismaticJoint_m_enableLimit_set)
    m_enableMotor = _swig_property(_Box2D2.b2PrismaticJoint_m_enableMotor_get, _Box2D2.b2PrismaticJoint_m_enableMotor_set)
    m_limitState = _swig_property(_Box2D2.b2PrismaticJoint_m_limitState_get, _Box2D2.b2PrismaticJoint_m_limitState_set)
    def __repr__(self):
        return b2JointInfo(self)

    __swig_destroy__ = _Box2D2.delete_b2PrismaticJoint
b2PrismaticJoint.GetJointTranslation = new_instancemethod(_Box2D2.b2PrismaticJoint_GetJointTranslation,None,b2PrismaticJoint)
b2PrismaticJoint.GetJointSpeed = new_instancemethod(_Box2D2.b2PrismaticJoint_GetJointSpeed,None,b2PrismaticJoint)
b2PrismaticJoint.IsLimitEnabled = new_instancemethod(_Box2D2.b2PrismaticJoint_IsLimitEnabled,None,b2PrismaticJoint)
b2PrismaticJoint.EnableLimit = new_instancemethod(_Box2D2.b2PrismaticJoint_EnableLimit,None,b2PrismaticJoint)
b2PrismaticJoint.GetLowerLimit = new_instancemethod(_Box2D2.b2PrismaticJoint_GetLowerLimit,None,b2PrismaticJoint)
b2PrismaticJoint.GetUpperLimit = new_instancemethod(_Box2D2.b2PrismaticJoint_GetUpperLimit,None,b2PrismaticJoint)
b2PrismaticJoint.SetLimits = new_instancemethod(_Box2D2.b2PrismaticJoint_SetLimits,None,b2PrismaticJoint)
b2PrismaticJoint.IsMotorEnabled = new_instancemethod(_Box2D2.b2PrismaticJoint_IsMotorEnabled,None,b2PrismaticJoint)
b2PrismaticJoint.EnableMotor = new_instancemethod(_Box2D2.b2PrismaticJoint_EnableMotor,None,b2PrismaticJoint)
b2PrismaticJoint.SetMotorSpeed = new_instancemethod(_Box2D2.b2PrismaticJoint_SetMotorSpeed,None,b2PrismaticJoint)
b2PrismaticJoint.GetMotorSpeed = new_instancemethod(_Box2D2.b2PrismaticJoint_GetMotorSpeed,None,b2PrismaticJoint)
b2PrismaticJoint.SetMaxMotorForce = new_instancemethod(_Box2D2.b2PrismaticJoint_SetMaxMotorForce,None,b2PrismaticJoint)
b2PrismaticJoint.GetMotorForce = new_instancemethod(_Box2D2.b2PrismaticJoint_GetMotorForce,None,b2PrismaticJoint)
b2PrismaticJoint.InitVelocityConstraints = new_instancemethod(_Box2D2.b2PrismaticJoint_InitVelocityConstraints,None,b2PrismaticJoint)
b2PrismaticJoint.SolveVelocityConstraints = new_instancemethod(_Box2D2.b2PrismaticJoint_SolveVelocityConstraints,None,b2PrismaticJoint)
b2PrismaticJoint.SolvePositionConstraints = new_instancemethod(_Box2D2.b2PrismaticJoint_SolvePositionConstraints,None,b2PrismaticJoint)
b2PrismaticJoint_swigregister = _Box2D2.b2PrismaticJoint_swigregister
b2PrismaticJoint_swigregister(b2PrismaticJoint)

class b2RevoluteJointDef(b2JointDef):
    """Proxy of C++ b2RevoluteJointDef class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self) -> b2RevoluteJointDef"""
        _Box2D2.b2RevoluteJointDef_swiginit(self,_Box2D2.new_b2RevoluteJointDef(*args))
    def Initialize(*args):
        """Initialize(self, b2Body body1, b2Body body2, b2Vec2 anchor)"""
        return _Box2D2.b2RevoluteJointDef_Initialize(*args)

    localAnchor1 = _swig_property(_Box2D2.b2RevoluteJointDef_localAnchor1_get, _Box2D2.b2RevoluteJointDef_localAnchor1_set)
    localAnchor2 = _swig_property(_Box2D2.b2RevoluteJointDef_localAnchor2_get, _Box2D2.b2RevoluteJointDef_localAnchor2_set)
    referenceAngle = _swig_property(_Box2D2.b2RevoluteJointDef_referenceAngle_get, _Box2D2.b2RevoluteJointDef_referenceAngle_set)
    enableLimit = _swig_property(_Box2D2.b2RevoluteJointDef_enableLimit_get, _Box2D2.b2RevoluteJointDef_enableLimit_set)
    lowerAngle = _swig_property(_Box2D2.b2RevoluteJointDef_lowerAngle_get, _Box2D2.b2RevoluteJointDef_lowerAngle_set)
    upperAngle = _swig_property(_Box2D2.b2RevoluteJointDef_upperAngle_get, _Box2D2.b2RevoluteJointDef_upperAngle_set)
    enableMotor = _swig_property(_Box2D2.b2RevoluteJointDef_enableMotor_get, _Box2D2.b2RevoluteJointDef_enableMotor_set)
    motorSpeed = _swig_property(_Box2D2.b2RevoluteJointDef_motorSpeed_get, _Box2D2.b2RevoluteJointDef_motorSpeed_set)
    maxMotorTorque = _swig_property(_Box2D2.b2RevoluteJointDef_maxMotorTorque_get, _Box2D2.b2RevoluteJointDef_maxMotorTorque_set)
    __swig_destroy__ = _Box2D2.delete_b2RevoluteJointDef
b2RevoluteJointDef.Initialize = new_instancemethod(_Box2D2.b2RevoluteJointDef_Initialize,None,b2RevoluteJointDef)
b2RevoluteJointDef_swigregister = _Box2D2.b2RevoluteJointDef_swigregister
b2RevoluteJointDef_swigregister(b2RevoluteJointDef)

class b2RevoluteJoint(b2Joint):
    """Proxy of C++ b2RevoluteJoint class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def GetJointAngle(*args):
        """GetJointAngle(self) -> float32"""
        return _Box2D2.b2RevoluteJoint_GetJointAngle(*args)

    def GetJointSpeed(*args):
        """GetJointSpeed(self) -> float32"""
        return _Box2D2.b2RevoluteJoint_GetJointSpeed(*args)

    def IsLimitEnabled(*args):
        """IsLimitEnabled(self) -> bool"""
        return _Box2D2.b2RevoluteJoint_IsLimitEnabled(*args)

    def EnableLimit(*args):
        """EnableLimit(self, bool flag)"""
        return _Box2D2.b2RevoluteJoint_EnableLimit(*args)

    def GetLowerLimit(*args):
        """GetLowerLimit(self) -> float32"""
        return _Box2D2.b2RevoluteJoint_GetLowerLimit(*args)

    def GetUpperLimit(*args):
        """GetUpperLimit(self) -> float32"""
        return _Box2D2.b2RevoluteJoint_GetUpperLimit(*args)

    def SetLimits(*args):
        """SetLimits(self, float32 lower, float32 upper)"""
        return _Box2D2.b2RevoluteJoint_SetLimits(*args)

    def IsMotorEnabled(*args):
        """IsMotorEnabled(self) -> bool"""
        return _Box2D2.b2RevoluteJoint_IsMotorEnabled(*args)

    def EnableMotor(*args):
        """EnableMotor(self, bool flag)"""
        return _Box2D2.b2RevoluteJoint_EnableMotor(*args)

    def SetMotorSpeed(*args):
        """SetMotorSpeed(self, float32 speed)"""
        return _Box2D2.b2RevoluteJoint_SetMotorSpeed(*args)

    def GetMotorSpeed(*args):
        """GetMotorSpeed(self) -> float32"""
        return _Box2D2.b2RevoluteJoint_GetMotorSpeed(*args)

    def SetMaxMotorTorque(*args):
        """SetMaxMotorTorque(self, float32 torque)"""
        return _Box2D2.b2RevoluteJoint_SetMaxMotorTorque(*args)

    def GetMotorTorque(*args):
        """GetMotorTorque(self) -> float32"""
        return _Box2D2.b2RevoluteJoint_GetMotorTorque(*args)

    def __init__(self, *args): 
        """__init__(self, b2RevoluteJointDef def) -> b2RevoluteJoint"""
        _Box2D2.b2RevoluteJoint_swiginit(self,_Box2D2.new_b2RevoluteJoint(*args))
    def InitVelocityConstraints(*args):
        """InitVelocityConstraints(self, b2TimeStep step)"""
        return _Box2D2.b2RevoluteJoint_InitVelocityConstraints(*args)

    def SolveVelocityConstraints(*args):
        """SolveVelocityConstraints(self, b2TimeStep step)"""
        return _Box2D2.b2RevoluteJoint_SolveVelocityConstraints(*args)

    def SolvePositionConstraints(*args):
        """SolvePositionConstraints(self) -> bool"""
        return _Box2D2.b2RevoluteJoint_SolvePositionConstraints(*args)

    m_localAnchor1 = _swig_property(_Box2D2.b2RevoluteJoint_m_localAnchor1_get, _Box2D2.b2RevoluteJoint_m_localAnchor1_set)
    m_localAnchor2 = _swig_property(_Box2D2.b2RevoluteJoint_m_localAnchor2_get, _Box2D2.b2RevoluteJoint_m_localAnchor2_set)
    m_pivotForce = _swig_property(_Box2D2.b2RevoluteJoint_m_pivotForce_get, _Box2D2.b2RevoluteJoint_m_pivotForce_set)
    m_motorForce = _swig_property(_Box2D2.b2RevoluteJoint_m_motorForce_get, _Box2D2.b2RevoluteJoint_m_motorForce_set)
    m_limitForce = _swig_property(_Box2D2.b2RevoluteJoint_m_limitForce_get, _Box2D2.b2RevoluteJoint_m_limitForce_set)
    m_limitPositionImpulse = _swig_property(_Box2D2.b2RevoluteJoint_m_limitPositionImpulse_get, _Box2D2.b2RevoluteJoint_m_limitPositionImpulse_set)
    m_pivotMass = _swig_property(_Box2D2.b2RevoluteJoint_m_pivotMass_get, _Box2D2.b2RevoluteJoint_m_pivotMass_set)
    m_motorMass = _swig_property(_Box2D2.b2RevoluteJoint_m_motorMass_get, _Box2D2.b2RevoluteJoint_m_motorMass_set)
    m_enableMotor = _swig_property(_Box2D2.b2RevoluteJoint_m_enableMotor_get, _Box2D2.b2RevoluteJoint_m_enableMotor_set)
    m_maxMotorTorque = _swig_property(_Box2D2.b2RevoluteJoint_m_maxMotorTorque_get, _Box2D2.b2RevoluteJoint_m_maxMotorTorque_set)
    m_motorSpeed = _swig_property(_Box2D2.b2RevoluteJoint_m_motorSpeed_get, _Box2D2.b2RevoluteJoint_m_motorSpeed_set)
    m_enableLimit = _swig_property(_Box2D2.b2RevoluteJoint_m_enableLimit_get, _Box2D2.b2RevoluteJoint_m_enableLimit_set)
    m_referenceAngle = _swig_property(_Box2D2.b2RevoluteJoint_m_referenceAngle_get, _Box2D2.b2RevoluteJoint_m_referenceAngle_set)
    m_lowerAngle = _swig_property(_Box2D2.b2RevoluteJoint_m_lowerAngle_get, _Box2D2.b2RevoluteJoint_m_lowerAngle_set)
    m_upperAngle = _swig_property(_Box2D2.b2RevoluteJoint_m_upperAngle_get, _Box2D2.b2RevoluteJoint_m_upperAngle_set)
    m_limitState = _swig_property(_Box2D2.b2RevoluteJoint_m_limitState_get, _Box2D2.b2RevoluteJoint_m_limitState_set)
    def __repr__(self):
        return b2JointInfo(self)

    __swig_destroy__ = _Box2D2.delete_b2RevoluteJoint
b2RevoluteJoint.GetJointAngle = new_instancemethod(_Box2D2.b2RevoluteJoint_GetJointAngle,None,b2RevoluteJoint)
b2RevoluteJoint.GetJointSpeed = new_instancemethod(_Box2D2.b2RevoluteJoint_GetJointSpeed,None,b2RevoluteJoint)
b2RevoluteJoint.IsLimitEnabled = new_instancemethod(_Box2D2.b2RevoluteJoint_IsLimitEnabled,None,b2RevoluteJoint)
b2RevoluteJoint.EnableLimit = new_instancemethod(_Box2D2.b2RevoluteJoint_EnableLimit,None,b2RevoluteJoint)
b2RevoluteJoint.GetLowerLimit = new_instancemethod(_Box2D2.b2RevoluteJoint_GetLowerLimit,None,b2RevoluteJoint)
b2RevoluteJoint.GetUpperLimit = new_instancemethod(_Box2D2.b2RevoluteJoint_GetUpperLimit,None,b2RevoluteJoint)
b2RevoluteJoint.SetLimits = new_instancemethod(_Box2D2.b2RevoluteJoint_SetLimits,None,b2RevoluteJoint)
b2RevoluteJoint.IsMotorEnabled = new_instancemethod(_Box2D2.b2RevoluteJoint_IsMotorEnabled,None,b2RevoluteJoint)
b2RevoluteJoint.EnableMotor = new_instancemethod(_Box2D2.b2RevoluteJoint_EnableMotor,None,b2RevoluteJoint)
b2RevoluteJoint.SetMotorSpeed = new_instancemethod(_Box2D2.b2RevoluteJoint_SetMotorSpeed,None,b2RevoluteJoint)
b2RevoluteJoint.GetMotorSpeed = new_instancemethod(_Box2D2.b2RevoluteJoint_GetMotorSpeed,None,b2RevoluteJoint)
b2RevoluteJoint.SetMaxMotorTorque = new_instancemethod(_Box2D2.b2RevoluteJoint_SetMaxMotorTorque,None,b2RevoluteJoint)
b2RevoluteJoint.GetMotorTorque = new_instancemethod(_Box2D2.b2RevoluteJoint_GetMotorTorque,None,b2RevoluteJoint)
b2RevoluteJoint.InitVelocityConstraints = new_instancemethod(_Box2D2.b2RevoluteJoint_InitVelocityConstraints,None,b2RevoluteJoint)
b2RevoluteJoint.SolveVelocityConstraints = new_instancemethod(_Box2D2.b2RevoluteJoint_SolveVelocityConstraints,None,b2RevoluteJoint)
b2RevoluteJoint.SolvePositionConstraints = new_instancemethod(_Box2D2.b2RevoluteJoint_SolvePositionConstraints,None,b2RevoluteJoint)
b2RevoluteJoint_swigregister = _Box2D2.b2RevoluteJoint_swigregister
b2RevoluteJoint_swigregister(b2RevoluteJoint)

class b2PulleyJointDef(b2JointDef):
    """Proxy of C++ b2PulleyJointDef class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self) -> b2PulleyJointDef"""
        _Box2D2.b2PulleyJointDef_swiginit(self,_Box2D2.new_b2PulleyJointDef(*args))
    def Initialize(*args):
        """
        Initialize(self, b2Body body1, b2Body body2, b2Vec2 groundAnchor1, b2Vec2 groundAnchor2, 
            b2Vec2 anchor1, b2Vec2 anchor2, 
            float32 ratio)
        """
        return _Box2D2.b2PulleyJointDef_Initialize(*args)

    groundAnchor1 = _swig_property(_Box2D2.b2PulleyJointDef_groundAnchor1_get, _Box2D2.b2PulleyJointDef_groundAnchor1_set)
    groundAnchor2 = _swig_property(_Box2D2.b2PulleyJointDef_groundAnchor2_get, _Box2D2.b2PulleyJointDef_groundAnchor2_set)
    localAnchor1 = _swig_property(_Box2D2.b2PulleyJointDef_localAnchor1_get, _Box2D2.b2PulleyJointDef_localAnchor1_set)
    localAnchor2 = _swig_property(_Box2D2.b2PulleyJointDef_localAnchor2_get, _Box2D2.b2PulleyJointDef_localAnchor2_set)
    length1 = _swig_property(_Box2D2.b2PulleyJointDef_length1_get, _Box2D2.b2PulleyJointDef_length1_set)
    maxLength1 = _swig_property(_Box2D2.b2PulleyJointDef_maxLength1_get, _Box2D2.b2PulleyJointDef_maxLength1_set)
    length2 = _swig_property(_Box2D2.b2PulleyJointDef_length2_get, _Box2D2.b2PulleyJointDef_length2_set)
    maxLength2 = _swig_property(_Box2D2.b2PulleyJointDef_maxLength2_get, _Box2D2.b2PulleyJointDef_maxLength2_set)
    ratio = _swig_property(_Box2D2.b2PulleyJointDef_ratio_get, _Box2D2.b2PulleyJointDef_ratio_set)
    __swig_destroy__ = _Box2D2.delete_b2PulleyJointDef
b2PulleyJointDef.Initialize = new_instancemethod(_Box2D2.b2PulleyJointDef_Initialize,None,b2PulleyJointDef)
b2PulleyJointDef_swigregister = _Box2D2.b2PulleyJointDef_swigregister
b2PulleyJointDef_swigregister(b2PulleyJointDef)
b2_minPulleyLength = cvar.b2_minPulleyLength

class b2PulleyJoint(b2Joint):
    """Proxy of C++ b2PulleyJoint class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def GetGroundAnchor1(*args):
        """GetGroundAnchor1(self) -> b2Vec2"""
        return _Box2D2.b2PulleyJoint_GetGroundAnchor1(*args)

    def GetGroundAnchor2(*args):
        """GetGroundAnchor2(self) -> b2Vec2"""
        return _Box2D2.b2PulleyJoint_GetGroundAnchor2(*args)

    def GetLength1(*args):
        """GetLength1(self) -> float32"""
        return _Box2D2.b2PulleyJoint_GetLength1(*args)

    def GetLength2(*args):
        """GetLength2(self) -> float32"""
        return _Box2D2.b2PulleyJoint_GetLength2(*args)

    def GetRatio(*args):
        """GetRatio(self) -> float32"""
        return _Box2D2.b2PulleyJoint_GetRatio(*args)

    def __init__(self, *args): 
        """__init__(self, b2PulleyJointDef data) -> b2PulleyJoint"""
        _Box2D2.b2PulleyJoint_swiginit(self,_Box2D2.new_b2PulleyJoint(*args))
    def InitVelocityConstraints(*args):
        """InitVelocityConstraints(self, b2TimeStep step)"""
        return _Box2D2.b2PulleyJoint_InitVelocityConstraints(*args)

    def SolveVelocityConstraints(*args):
        """SolveVelocityConstraints(self, b2TimeStep step)"""
        return _Box2D2.b2PulleyJoint_SolveVelocityConstraints(*args)

    def SolvePositionConstraints(*args):
        """SolvePositionConstraints(self) -> bool"""
        return _Box2D2.b2PulleyJoint_SolvePositionConstraints(*args)

    m_ground = _swig_property(_Box2D2.b2PulleyJoint_m_ground_get, _Box2D2.b2PulleyJoint_m_ground_set)
    m_groundAnchor1 = _swig_property(_Box2D2.b2PulleyJoint_m_groundAnchor1_get, _Box2D2.b2PulleyJoint_m_groundAnchor1_set)
    m_groundAnchor2 = _swig_property(_Box2D2.b2PulleyJoint_m_groundAnchor2_get, _Box2D2.b2PulleyJoint_m_groundAnchor2_set)
    m_localAnchor1 = _swig_property(_Box2D2.b2PulleyJoint_m_localAnchor1_get, _Box2D2.b2PulleyJoint_m_localAnchor1_set)
    m_localAnchor2 = _swig_property(_Box2D2.b2PulleyJoint_m_localAnchor2_get, _Box2D2.b2PulleyJoint_m_localAnchor2_set)
    m_u1 = _swig_property(_Box2D2.b2PulleyJoint_m_u1_get, _Box2D2.b2PulleyJoint_m_u1_set)
    m_u2 = _swig_property(_Box2D2.b2PulleyJoint_m_u2_get, _Box2D2.b2PulleyJoint_m_u2_set)
    m_constant = _swig_property(_Box2D2.b2PulleyJoint_m_constant_get, _Box2D2.b2PulleyJoint_m_constant_set)
    m_ratio = _swig_property(_Box2D2.b2PulleyJoint_m_ratio_get, _Box2D2.b2PulleyJoint_m_ratio_set)
    m_maxLength1 = _swig_property(_Box2D2.b2PulleyJoint_m_maxLength1_get, _Box2D2.b2PulleyJoint_m_maxLength1_set)
    m_maxLength2 = _swig_property(_Box2D2.b2PulleyJoint_m_maxLength2_get, _Box2D2.b2PulleyJoint_m_maxLength2_set)
    m_pulleyMass = _swig_property(_Box2D2.b2PulleyJoint_m_pulleyMass_get, _Box2D2.b2PulleyJoint_m_pulleyMass_set)
    m_limitMass1 = _swig_property(_Box2D2.b2PulleyJoint_m_limitMass1_get, _Box2D2.b2PulleyJoint_m_limitMass1_set)
    m_limitMass2 = _swig_property(_Box2D2.b2PulleyJoint_m_limitMass2_get, _Box2D2.b2PulleyJoint_m_limitMass2_set)
    m_force = _swig_property(_Box2D2.b2PulleyJoint_m_force_get, _Box2D2.b2PulleyJoint_m_force_set)
    m_limitForce1 = _swig_property(_Box2D2.b2PulleyJoint_m_limitForce1_get, _Box2D2.b2PulleyJoint_m_limitForce1_set)
    m_limitForce2 = _swig_property(_Box2D2.b2PulleyJoint_m_limitForce2_get, _Box2D2.b2PulleyJoint_m_limitForce2_set)
    m_positionImpulse = _swig_property(_Box2D2.b2PulleyJoint_m_positionImpulse_get, _Box2D2.b2PulleyJoint_m_positionImpulse_set)
    m_limitPositionImpulse1 = _swig_property(_Box2D2.b2PulleyJoint_m_limitPositionImpulse1_get, _Box2D2.b2PulleyJoint_m_limitPositionImpulse1_set)
    m_limitPositionImpulse2 = _swig_property(_Box2D2.b2PulleyJoint_m_limitPositionImpulse2_get, _Box2D2.b2PulleyJoint_m_limitPositionImpulse2_set)
    m_state = _swig_property(_Box2D2.b2PulleyJoint_m_state_get, _Box2D2.b2PulleyJoint_m_state_set)
    m_limitState1 = _swig_property(_Box2D2.b2PulleyJoint_m_limitState1_get, _Box2D2.b2PulleyJoint_m_limitState1_set)
    m_limitState2 = _swig_property(_Box2D2.b2PulleyJoint_m_limitState2_get, _Box2D2.b2PulleyJoint_m_limitState2_set)
    def __repr__(self):
        return b2JointInfo(self)

    __swig_destroy__ = _Box2D2.delete_b2PulleyJoint
b2PulleyJoint.GetGroundAnchor1 = new_instancemethod(_Box2D2.b2PulleyJoint_GetGroundAnchor1,None,b2PulleyJoint)
b2PulleyJoint.GetGroundAnchor2 = new_instancemethod(_Box2D2.b2PulleyJoint_GetGroundAnchor2,None,b2PulleyJoint)
b2PulleyJoint.GetLength1 = new_instancemethod(_Box2D2.b2PulleyJoint_GetLength1,None,b2PulleyJoint)
b2PulleyJoint.GetLength2 = new_instancemethod(_Box2D2.b2PulleyJoint_GetLength2,None,b2PulleyJoint)
b2PulleyJoint.GetRatio = new_instancemethod(_Box2D2.b2PulleyJoint_GetRatio,None,b2PulleyJoint)
b2PulleyJoint.InitVelocityConstraints = new_instancemethod(_Box2D2.b2PulleyJoint_InitVelocityConstraints,None,b2PulleyJoint)
b2PulleyJoint.SolveVelocityConstraints = new_instancemethod(_Box2D2.b2PulleyJoint_SolveVelocityConstraints,None,b2PulleyJoint)
b2PulleyJoint.SolvePositionConstraints = new_instancemethod(_Box2D2.b2PulleyJoint_SolvePositionConstraints,None,b2PulleyJoint)
b2PulleyJoint_swigregister = _Box2D2.b2PulleyJoint_swigregister
b2PulleyJoint_swigregister(b2PulleyJoint)

class b2GearJointDef(b2JointDef):
    """Proxy of C++ b2GearJointDef class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self) -> b2GearJointDef"""
        _Box2D2.b2GearJointDef_swiginit(self,_Box2D2.new_b2GearJointDef(*args))
    joint1 = _swig_property(_Box2D2.b2GearJointDef_joint1_get, _Box2D2.b2GearJointDef_joint1_set)
    joint2 = _swig_property(_Box2D2.b2GearJointDef_joint2_get, _Box2D2.b2GearJointDef_joint2_set)
    ratio = _swig_property(_Box2D2.b2GearJointDef_ratio_get, _Box2D2.b2GearJointDef_ratio_set)
    __swig_destroy__ = _Box2D2.delete_b2GearJointDef
b2GearJointDef_swigregister = _Box2D2.b2GearJointDef_swigregister
b2GearJointDef_swigregister(b2GearJointDef)

class b2GearJoint(b2Joint):
    """Proxy of C++ b2GearJoint class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def GetRatio(*args):
        """GetRatio(self) -> float32"""
        return _Box2D2.b2GearJoint_GetRatio(*args)

    def __init__(self, *args): 
        """__init__(self, b2GearJointDef data) -> b2GearJoint"""
        _Box2D2.b2GearJoint_swiginit(self,_Box2D2.new_b2GearJoint(*args))
    def InitVelocityConstraints(*args):
        """InitVelocityConstraints(self, b2TimeStep step)"""
        return _Box2D2.b2GearJoint_InitVelocityConstraints(*args)

    def SolveVelocityConstraints(*args):
        """SolveVelocityConstraints(self, b2TimeStep step)"""
        return _Box2D2.b2GearJoint_SolveVelocityConstraints(*args)

    def SolvePositionConstraints(*args):
        """SolvePositionConstraints(self) -> bool"""
        return _Box2D2.b2GearJoint_SolvePositionConstraints(*args)

    m_ground1 = _swig_property(_Box2D2.b2GearJoint_m_ground1_get, _Box2D2.b2GearJoint_m_ground1_set)
    m_ground2 = _swig_property(_Box2D2.b2GearJoint_m_ground2_get, _Box2D2.b2GearJoint_m_ground2_set)
    m_revolute1 = _swig_property(_Box2D2.b2GearJoint_m_revolute1_get, _Box2D2.b2GearJoint_m_revolute1_set)
    m_prismatic1 = _swig_property(_Box2D2.b2GearJoint_m_prismatic1_get, _Box2D2.b2GearJoint_m_prismatic1_set)
    m_revolute2 = _swig_property(_Box2D2.b2GearJoint_m_revolute2_get, _Box2D2.b2GearJoint_m_revolute2_set)
    m_prismatic2 = _swig_property(_Box2D2.b2GearJoint_m_prismatic2_get, _Box2D2.b2GearJoint_m_prismatic2_set)
    m_groundAnchor1 = _swig_property(_Box2D2.b2GearJoint_m_groundAnchor1_get, _Box2D2.b2GearJoint_m_groundAnchor1_set)
    m_groundAnchor2 = _swig_property(_Box2D2.b2GearJoint_m_groundAnchor2_get, _Box2D2.b2GearJoint_m_groundAnchor2_set)
    m_localAnchor1 = _swig_property(_Box2D2.b2GearJoint_m_localAnchor1_get, _Box2D2.b2GearJoint_m_localAnchor1_set)
    m_localAnchor2 = _swig_property(_Box2D2.b2GearJoint_m_localAnchor2_get, _Box2D2.b2GearJoint_m_localAnchor2_set)
    m_J = _swig_property(_Box2D2.b2GearJoint_m_J_get, _Box2D2.b2GearJoint_m_J_set)
    m_constant = _swig_property(_Box2D2.b2GearJoint_m_constant_get, _Box2D2.b2GearJoint_m_constant_set)
    m_ratio = _swig_property(_Box2D2.b2GearJoint_m_ratio_get, _Box2D2.b2GearJoint_m_ratio_set)
    m_mass = _swig_property(_Box2D2.b2GearJoint_m_mass_get, _Box2D2.b2GearJoint_m_mass_set)
    m_force = _swig_property(_Box2D2.b2GearJoint_m_force_get, _Box2D2.b2GearJoint_m_force_set)
    def __repr__(self):
        return b2JointInfo(self)

    __swig_destroy__ = _Box2D2.delete_b2GearJoint
b2GearJoint.GetRatio = new_instancemethod(_Box2D2.b2GearJoint_GetRatio,None,b2GearJoint)
b2GearJoint.InitVelocityConstraints = new_instancemethod(_Box2D2.b2GearJoint_InitVelocityConstraints,None,b2GearJoint)
b2GearJoint.SolveVelocityConstraints = new_instancemethod(_Box2D2.b2GearJoint_SolveVelocityConstraints,None,b2GearJoint)
b2GearJoint.SolvePositionConstraints = new_instancemethod(_Box2D2.b2GearJoint_SolvePositionConstraints,None,b2GearJoint)
b2GearJoint_swigregister = _Box2D2.b2GearJoint_swigregister
b2GearJoint_swigregister(b2GearJoint)



