# This file was automatically generated by SWIG (http://www.swig.org).
# Version 1.3.39
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.
# This file is compatible with both classic and new-style classes.

from sys import version_info
if version_info >= (2,6,0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_Physics', [dirname(__file__)])
        except ImportError:
            import _Physics
            return _Physics
        if fp is not None:
            try:
                _mod = imp.load_module('_Physics', fp, pathname, description)
            finally:
                fp.close()
                return _mod
    _Physics = swig_import_helper()
    del swig_import_helper
else:
    import _Physics
del version_info
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__ == 'SwigPyObject':
            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,)

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object : pass
    _newclass = 0


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


import Utils
UNKNOWN_CDP = _Physics.UNKNOWN_CDP
SPHERE_CDP = _Physics.SPHERE_CDP
CAPSULE_CDP = _Physics.CAPSULE_CDP
PLANE_CDP = _Physics.PLANE_CDP
BOX_CDP = _Physics.BOX_CDP
class CollisionDetectionPrimitive(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CollisionDetectionPrimitive, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CollisionDetectionPrimitive, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _Physics.delete_CollisionDetectionPrimitive
    __del__ = lambda self : None;
    def typeName(self): return _Physics.CollisionDetectionPrimitive_typeName(self)
    def save(self): return _Physics.CollisionDetectionPrimitive_save(self)
    def attachBody(self, *args): return _Physics.CollisionDetectionPrimitive_attachBody(self, *args)
    def updateToWorldPrimitive(self): return _Physics.CollisionDetectionPrimitive_updateToWorldPrimitive(self)
    def draw(self): return _Physics.CollisionDetectionPrimitive_draw(self)
    def getType(self): return _Physics.CollisionDetectionPrimitive_getType(self)
    def computeCollisionsWith(self, *args): return _Physics.CollisionDetectionPrimitive_computeCollisionsWith(self, *args)
    def computeCollisionsWithSphereCDP(self, *args): return _Physics.CollisionDetectionPrimitive_computeCollisionsWithSphereCDP(self, *args)
    def computeCollisionsWithPlaneCDP(self, *args): return _Physics.CollisionDetectionPrimitive_computeCollisionsWithPlaneCDP(self, *args)
    def computeCollisionsWithCapsuleCDP(self, *args): return _Physics.CollisionDetectionPrimitive_computeCollisionsWithCapsuleCDP(self, *args)
    def computeCollisionsWithBoxCDP(self, *args): return _Physics.CollisionDetectionPrimitive_computeCollisionsWithBoxCDP(self, *args)
CollisionDetectionPrimitive_swigregister = _Physics.CollisionDetectionPrimitive_swigregister
CollisionDetectionPrimitive_swigregister(CollisionDetectionPrimitive)

class BoxCDP(CollisionDetectionPrimitive):
    __swig_setmethods__ = {}
    for _s in [CollisionDetectionPrimitive]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BoxCDP, name, value)
    __swig_getmethods__ = {}
    for _s in [CollisionDetectionPrimitive]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, BoxCDP, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _Physics.new_BoxCDP(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _Physics.delete_BoxCDP
    __del__ = lambda self : None;
    def save(self): return _Physics.BoxCDP_save(self)
    def updateToWorldPrimitive(self): return _Physics.BoxCDP_updateToWorldPrimitive(self)
    def draw(self): return _Physics.BoxCDP_draw(self)
    def getPoint1(self): return _Physics.BoxCDP_getPoint1(self)
    def setPoint1(self, *args): return _Physics.BoxCDP_setPoint1(self, *args)
    def getPoint2(self): return _Physics.BoxCDP_getPoint2(self)
    def setPoint2(self, *args): return _Physics.BoxCDP_setPoint2(self, *args)
    def getCenter(self): return _Physics.BoxCDP_getCenter(self)
    def getXLen(self): return _Physics.BoxCDP_getXLen(self)
    def getYLen(self): return _Physics.BoxCDP_getYLen(self)
    def getZLen(self): return _Physics.BoxCDP_getZLen(self)
    def computeCollisionsWith(self, *args): return _Physics.BoxCDP_computeCollisionsWith(self, *args)
    def computeCollisionsWithSphereCDP(self, *args): return _Physics.BoxCDP_computeCollisionsWithSphereCDP(self, *args)
    def computeCollisionsWithPlaneCDP(self, *args): return _Physics.BoxCDP_computeCollisionsWithPlaneCDP(self, *args)
    def computeCollisionsWithCapsuleCDP(self, *args): return _Physics.BoxCDP_computeCollisionsWithCapsuleCDP(self, *args)
    def computeCollisionsWithBoxCDP(self, *args): return _Physics.BoxCDP_computeCollisionsWithBoxCDP(self, *args)
BoxCDP_swigregister = _Physics.BoxCDP_swigregister
BoxCDP_swigregister(BoxCDP)

class CapsuleCDP(CollisionDetectionPrimitive):
    __swig_setmethods__ = {}
    for _s in [CollisionDetectionPrimitive]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CapsuleCDP, name, value)
    __swig_getmethods__ = {}
    for _s in [CollisionDetectionPrimitive]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CapsuleCDP, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _Physics.new_CapsuleCDP(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _Physics.delete_CapsuleCDP
    __del__ = lambda self : None;
    def save(self): return _Physics.CapsuleCDP_save(self)
    def updateToWorldPrimitive(self): return _Physics.CapsuleCDP_updateToWorldPrimitive(self)
    def draw(self): return _Physics.CapsuleCDP_draw(self)
    def getRadius(self): return _Physics.CapsuleCDP_getRadius(self)
    def setRadius(self, *args): return _Physics.CapsuleCDP_setRadius(self, *args)
    def getPoint1(self): return _Physics.CapsuleCDP_getPoint1(self)
    def setPoint1(self, *args): return _Physics.CapsuleCDP_setPoint1(self, *args)
    def getPoint2(self): return _Physics.CapsuleCDP_getPoint2(self)
    def setPoint2(self, *args): return _Physics.CapsuleCDP_setPoint2(self, *args)
    def computeCollisionsWith(self, *args): return _Physics.CapsuleCDP_computeCollisionsWith(self, *args)
    def computeCollisionsWithSphereCDP(self, *args): return _Physics.CapsuleCDP_computeCollisionsWithSphereCDP(self, *args)
    def computeCollisionsWithPlaneCDP(self, *args): return _Physics.CapsuleCDP_computeCollisionsWithPlaneCDP(self, *args)
    def computeCollisionsWithCapsuleCDP(self, *args): return _Physics.CapsuleCDP_computeCollisionsWithCapsuleCDP(self, *args)
    def computeCollisionsWithBoxCDP(self, *args): return _Physics.CapsuleCDP_computeCollisionsWithBoxCDP(self, *args)
CapsuleCDP_swigregister = _Physics.CapsuleCDP_swigregister
CapsuleCDP_swigregister(CapsuleCDP)

class PlaneCDP(CollisionDetectionPrimitive):
    __swig_setmethods__ = {}
    for _s in [CollisionDetectionPrimitive]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PlaneCDP, name, value)
    __swig_getmethods__ = {}
    for _s in [CollisionDetectionPrimitive]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PlaneCDP, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _Physics.new_PlaneCDP(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _Physics.delete_PlaneCDP
    __del__ = lambda self : None;
    def save(self): return _Physics.PlaneCDP_save(self)
    def updateToWorldPrimitive(self): return _Physics.PlaneCDP_updateToWorldPrimitive(self)
    def draw(self): return _Physics.PlaneCDP_draw(self)
    def getNormal(self): return _Physics.PlaneCDP_getNormal(self)
    def setNormal(self, *args): return _Physics.PlaneCDP_setNormal(self, *args)
    def getOrigin(self): return _Physics.PlaneCDP_getOrigin(self)
    def setOrigin(self, *args): return _Physics.PlaneCDP_setOrigin(self, *args)
    def computeCollisionsWith(self, *args): return _Physics.PlaneCDP_computeCollisionsWith(self, *args)
    def computeCollisionsWithSphereCDP(self, *args): return _Physics.PlaneCDP_computeCollisionsWithSphereCDP(self, *args)
    def computeCollisionsWithPlaneCDP(self, *args): return _Physics.PlaneCDP_computeCollisionsWithPlaneCDP(self, *args)
    def computeCollisionsWithCapsuleCDP(self, *args): return _Physics.PlaneCDP_computeCollisionsWithCapsuleCDP(self, *args)
    def computeCollisionsWithBoxCDP(self, *args): return _Physics.PlaneCDP_computeCollisionsWithBoxCDP(self, *args)
PlaneCDP_swigregister = _Physics.PlaneCDP_swigregister
PlaneCDP_swigregister(PlaneCDP)

class SphereCDP(CollisionDetectionPrimitive):
    __swig_setmethods__ = {}
    for _s in [CollisionDetectionPrimitive]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SphereCDP, name, value)
    __swig_getmethods__ = {}
    for _s in [CollisionDetectionPrimitive]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SphereCDP, name)
    __repr__ = _swig_repr
    __swig_setmethods__["s"] = _Physics.SphereCDP_s_set
    __swig_getmethods__["s"] = _Physics.SphereCDP_s_get
    if _newclass:s = _swig_property(_Physics.SphereCDP_s_get, _Physics.SphereCDP_s_set)
    __swig_setmethods__["wS"] = _Physics.SphereCDP_wS_set
    __swig_getmethods__["wS"] = _Physics.SphereCDP_wS_get
    if _newclass:wS = _swig_property(_Physics.SphereCDP_wS_get, _Physics.SphereCDP_wS_set)
    def __init__(self, *args): 
        this = _Physics.new_SphereCDP(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _Physics.delete_SphereCDP
    __del__ = lambda self : None;
    def save(self): return _Physics.SphereCDP_save(self)
    def updateToWorldPrimitive(self): return _Physics.SphereCDP_updateToWorldPrimitive(self)
    def draw(self): return _Physics.SphereCDP_draw(self)
    def getRadius(self): return _Physics.SphereCDP_getRadius(self)
    def setRadius(self, *args): return _Physics.SphereCDP_setRadius(self, *args)
    def getCenter(self): return _Physics.SphereCDP_getCenter(self)
    def setCenter(self, *args): return _Physics.SphereCDP_setCenter(self, *args)
    def computeCollisionsWith(self, *args): return _Physics.SphereCDP_computeCollisionsWith(self, *args)
    def computeCollisionsWithSphereCDP(self, *args): return _Physics.SphereCDP_computeCollisionsWithSphereCDP(self, *args)
    def computeCollisionsWithPlaneCDP(self, *args): return _Physics.SphereCDP_computeCollisionsWithPlaneCDP(self, *args)
    def computeCollisionsWithCapsuleCDP(self, *args): return _Physics.SphereCDP_computeCollisionsWithCapsuleCDP(self, *args)
    def computeCollisionsWithBoxCDP(self, *args): return _Physics.SphereCDP_computeCollisionsWithBoxCDP(self, *args)
SphereCDP_swigregister = _Physics.SphereCDP_swigregister
SphereCDP_swigregister(SphereCDP)

STIFF_JOINT = _Physics.STIFF_JOINT
HINGE_JOINT = _Physics.HINGE_JOINT
BALL_IN_SOCKET_JOINT = _Physics.BALL_IN_SOCKET_JOINT
UNIVERSAL_JOINT = _Physics.UNIVERSAL_JOINT
class Joint(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Joint, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Joint, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _Physics.delete_Joint
    __del__ = lambda self : None;
    def typeName(self): return _Physics.Joint_typeName(self)
    def fixJointConstraints(self, *args): return _Physics.Joint_fixJointConstraints(self, *args)
    def loadFromFile(self, *args): return _Physics.Joint_loadFromFile(self, *args)
    def getJointType(self): return _Physics.Joint_getJointType(self)
    def setTorque(self, *args): return _Physics.Joint_setTorque(self, *args)
    def getParent(self): return _Physics.Joint_getParent(self)
    def setParent(self, *args): return _Physics.Joint_setParent(self, *args)
    def getChild(self): return _Physics.Joint_getChild(self)
    def setChild(self, *args): return _Physics.Joint_setChild(self, *args)
    def getChildJointPosition(self): return _Physics.Joint_getChildJointPosition(self)
    def setChildJointPosition(self, *args): return _Physics.Joint_setChildJointPosition(self, *args)
    def getParentJointPosition(self): return _Physics.Joint_getParentJointPosition(self)
    def setParentJointPosition(self, *args): return _Physics.Joint_setParentJointPosition(self, *args)
    def getName(self): return _Physics.Joint_getName(self)
    def setName(self, *args): return _Physics.Joint_setName(self, *args)
Joint_swigregister = _Physics.Joint_swigregister
Joint_swigregister(Joint)

class StiffJoint(Joint):
    __swig_setmethods__ = {}
    for _s in [Joint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, StiffJoint, name, value)
    __swig_getmethods__ = {}
    for _s in [Joint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, StiffJoint, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _Physics.new_StiffJoint()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _Physics.delete_StiffJoint
    __del__ = lambda self : None;
    def fixAngularConstraint(self, *args): return _Physics.StiffJoint_fixAngularConstraint(self, *args)
    def getJointType(self): return _Physics.StiffJoint_getJointType(self)
StiffJoint_swigregister = _Physics.StiffJoint_swigregister
StiffJoint_swigregister(StiffJoint)

class HingeJoint(Joint):
    __swig_setmethods__ = {}
    for _s in [Joint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HingeJoint, name, value)
    __swig_getmethods__ = {}
    for _s in [Joint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, HingeJoint, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _Physics.new_HingeJoint()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _Physics.delete_HingeJoint
    __del__ = lambda self : None;
    def readAxes(self, *args): return _Physics.HingeJoint_readAxes(self, *args)
    def setAxis(self, *args): return _Physics.HingeJoint_setAxis(self, *args)
    def getAxis(self): return _Physics.HingeJoint_getAxis(self)
    def readJointLimits(self, *args): return _Physics.HingeJoint_readJointLimits(self, *args)
    def setJointLimits(self, *args): return _Physics.HingeJoint_setJointLimits(self, *args)
    def fixAngularConstraint(self, *args): return _Physics.HingeJoint_fixAngularConstraint(self, *args)
    def getRotAxisA(self): return _Physics.HingeJoint_getRotAxisA(self)
    def getJointType(self): return _Physics.HingeJoint_getJointType(self)
HingeJoint_swigregister = _Physics.HingeJoint_swigregister
HingeJoint_swigregister(HingeJoint)

class UniversalJoint(Joint):
    __swig_setmethods__ = {}
    for _s in [Joint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, UniversalJoint, name, value)
    __swig_getmethods__ = {}
    for _s in [Joint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, UniversalJoint, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _Physics.new_UniversalJoint()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _Physics.delete_UniversalJoint
    __del__ = lambda self : None;
    def readAxes(self, *args): return _Physics.UniversalJoint_readAxes(self, *args)
    def setAxes(self, *args): return _Physics.UniversalJoint_setAxes(self, *args)
    def setParentAxis(self, *args): return _Physics.UniversalJoint_setParentAxis(self, *args)
    def getParentAxis(self): return _Physics.UniversalJoint_getParentAxis(self)
    def setChildAxis(self, *args): return _Physics.UniversalJoint_setChildAxis(self, *args)
    def getChildAxis(self): return _Physics.UniversalJoint_getChildAxis(self)
    def readJointLimits(self, *args): return _Physics.UniversalJoint_readJointLimits(self, *args)
    def setJointLimits(self, *args): return _Physics.UniversalJoint_setJointLimits(self, *args)
    def fixAngularConstraint(self, *args): return _Physics.UniversalJoint_fixAngularConstraint(self, *args)
    def getRotAxisA(self): return _Physics.UniversalJoint_getRotAxisA(self)
    def getRotAxisB(self): return _Physics.UniversalJoint_getRotAxisB(self)
    def getJointType(self): return _Physics.UniversalJoint_getJointType(self)
UniversalJoint_swigregister = _Physics.UniversalJoint_swigregister
UniversalJoint_swigregister(UniversalJoint)

class BallInSocketJoint(Joint):
    __swig_setmethods__ = {}
    for _s in [Joint]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BallInSocketJoint, name, value)
    __swig_getmethods__ = {}
    for _s in [Joint]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, BallInSocketJoint, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _Physics.new_BallInSocketJoint()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _Physics.delete_BallInSocketJoint
    __del__ = lambda self : None;
    def fixAngularConstraint(self, *args): return _Physics.BallInSocketJoint_fixAngularConstraint(self, *args)
    def readJointLimits(self, *args): return _Physics.BallInSocketJoint_readJointLimits(self, *args)
    def setJointLimits(self, *args): return _Physics.BallInSocketJoint_setJointLimits(self, *args)
    def readAxes(self, *args): return _Physics.BallInSocketJoint_readAxes(self, *args)
    def setAxes(self, *args): return _Physics.BallInSocketJoint_setAxes(self, *args)
    def setSwingAxis1(self, *args): return _Physics.BallInSocketJoint_setSwingAxis1(self, *args)
    def getSwingAxis1(self): return _Physics.BallInSocketJoint_getSwingAxis1(self)
    def setSwingAxis2(self, *args): return _Physics.BallInSocketJoint_setSwingAxis2(self, *args)
    def getSwingAxis2(self): return _Physics.BallInSocketJoint_getSwingAxis2(self)
    def setTwistAxis(self, *args): return _Physics.BallInSocketJoint_setTwistAxis(self, *args)
    def getTwistAxis(self): return _Physics.BallInSocketJoint_getTwistAxis(self)
    def getJointType(self): return _Physics.BallInSocketJoint_getJointType(self)
BallInSocketJoint_swigregister = _Physics.BallInSocketJoint_swigregister
BallInSocketJoint_swigregister(BallInSocketJoint)

SHOW_MESH = _Physics.SHOW_MESH
SHOW_BODY_FRAME = _Physics.SHOW_BODY_FRAME
SHOW_CD_PRIMITIVES = _Physics.SHOW_CD_PRIMITIVES
SHOW_MIN_BDG_SPHERE = _Physics.SHOW_MIN_BDG_SPHERE
SHOW_JOINTS = _Physics.SHOW_JOINTS
SHOW_COLOURS = _Physics.SHOW_COLOURS
SHOW_FRICTION_PARTICLES = _Physics.SHOW_FRICTION_PARTICLES
SHOW_ABSTRACT_VIEW = _Physics.SHOW_ABSTRACT_VIEW
SHOW_ABSTRACT_VIEW_SKELETON = _Physics.SHOW_ABSTRACT_VIEW_SKELETON
class RigidBody(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, RigidBody, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, RigidBody, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _Physics.new_RigidBody()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _Physics.delete_RigidBody
    __del__ = lambda self : None;
    def typeName(self): return _Physics.RigidBody_typeName(self)
    def setExternalForce(self, *args): return _Physics.RigidBody_setExternalForce(self, *args)
    def setExternalTorque(self, *args): return _Physics.RigidBody_setExternalTorque(self, *args)
    def getExternalForce(self): return _Physics.RigidBody_getExternalForce(self)
    def getExternalTorque(self): return _Physics.RigidBody_getExternalTorque(self)
    def getLocalCoordinates(self, *args): return _Physics.RigidBody_getLocalCoordinates(self, *args)
    def getWorldCoordinates(self, *args): return _Physics.RigidBody_getWorldCoordinates(self, *args)
    def getAbsoluteVelocityForLocalPoint(self, *args): return _Physics.RigidBody_getAbsoluteVelocityForLocalPoint(self, *args)
    def getAbsoluteVelocityForGlobalPoint(self, *args): return _Physics.RigidBody_getAbsoluteVelocityForGlobalPoint(self, *args)
    def getCMPosition(self): return _Physics.RigidBody_getCMPosition(self)
    def setCMPosition(self, *args): return _Physics.RigidBody_setCMPosition(self, *args)
    def getCMVelocity(self): return _Physics.RigidBody_getCMVelocity(self)
    def setCMVelocity(self, *args): return _Physics.RigidBody_setCMVelocity(self, *args)
    def setAngularVelocity(self, *args): return _Physics.RigidBody_setAngularVelocity(self, *args)
    def getRestitutionCoefficient(self): return _Physics.RigidBody_getRestitutionCoefficient(self)
    def getFrictionCoefficient(self): return _Physics.RigidBody_getFrictionCoefficient(self)
    def draw(self, *args): return _Physics.RigidBody_draw(self, *args)
    def renderToObjFile(self, *args): return _Physics.RigidBody_renderToObjFile(self, *args)
    def loadFromFile(self, *args): return _Physics.RigidBody_loadFromFile(self, *args)
    def setName(self, *args): return _Physics.RigidBody_setName(self, *args)
    def getName(self): return _Physics.RigidBody_getName(self)
    def addMeshObj(self, *args): return _Physics.RigidBody_addMeshObj(self, *args)
    def setColour(self, *args): return _Physics.RigidBody_setColour(self, *args)
    def addMesh(self, *args): return _Physics.RigidBody_addMesh(self, *args)
    def getMeshCount(self): return _Physics.RigidBody_getMeshCount(self)
    def getMesh(self, *args): return _Physics.RigidBody_getMesh(self, *args)
    def getCDPCount(self): return _Physics.RigidBody_getCDPCount(self)
    def getCDP(self, *args): return _Physics.RigidBody_getCDP(self, *args)
    def setMass(self, *args): return _Physics.RigidBody_setMass(self, *args)
    def setMOI(self, *args): return _Physics.RigidBody_setMOI(self, *args)
    def getMOI(self): return _Physics.RigidBody_getMOI(self)
    def addCollisionDetectionPrimitive(self, *args): return _Physics.RigidBody_addCollisionDetectionPrimitive(self, *args)
    def getCollisionDetectionPrimitive(self, *args): return _Physics.RigidBody_getCollisionDetectionPrimitive(self, *args)
    def getCollisionDetectionPrimitiveCount(self): return _Physics.RigidBody_getCollisionDetectionPrimitiveCount(self)
    def lockBody(self, isLocked = True): return _Physics.RigidBody_lockBody(self, isLocked)
    def setFrictionCoefficient(self, *args): return _Physics.RigidBody_setFrictionCoefficient(self, *args)
    def setRestitutionCoefficient(self, *args): return _Physics.RigidBody_setRestitutionCoefficient(self, *args)
    def getGroundSoftness(self): return _Physics.RigidBody_getGroundSoftness(self)
    def getGroundPenalty(self): return _Physics.RigidBody_getGroundPenalty(self)
    def setODEGroundCoefficients(self, *args): return _Physics.RigidBody_setODEGroundCoefficients(self, *args)
    def getODEGroundSoftness(self): return _Physics.RigidBody_getODEGroundSoftness(self)
    def getODEGroundPenalty(self): return _Physics.RigidBody_getODEGroundPenalty(self)
    def setPlanar(self, *args): return _Physics.RigidBody_setPlanar(self, *args)
    def isPlanar(self): return _Physics.RigidBody_isPlanar(self)
    def getMass(self): return _Physics.RigidBody_getMass(self)
    def setBodyID(self, *args): return _Physics.RigidBody_setBodyID(self, *args)
    def getPMI(self): return _Physics.RigidBody_getPMI(self)
    def getOrientation(self): return _Physics.RigidBody_getOrientation(self)
    def setOrientation(self, *args): return _Physics.RigidBody_setOrientation(self, *args)
    def getAngularVelocity(self): return _Physics.RigidBody_getAngularVelocity(self)
    def isLocked(self): return _Physics.RigidBody_isLocked(self)
    def isArticulated(self): return _Physics.RigidBody_isArticulated(self)
    def updateWorldCDPs(self): return _Physics.RigidBody_updateWorldCDPs(self)
    def getAFParent(self): return _Physics.RigidBody_getAFParent(self)
RigidBody_swigregister = _Physics.RigidBody_swigregister
RigidBody_swigregister(RigidBody)

class ArticulatedRigidBody(RigidBody):
    __swig_setmethods__ = {}
    for _s in [RigidBody]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArticulatedRigidBody, name, value)
    __swig_getmethods__ = {}
    for _s in [RigidBody]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ArticulatedRigidBody, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _Physics.new_ArticulatedRigidBody()
        try: self.this.append(this)
        except: self.this = this
    def draw(self, *args): return _Physics.ArticulatedRigidBody_draw(self, *args)
    __swig_destroy__ = _Physics.delete_ArticulatedRigidBody
    __del__ = lambda self : None;
    def getParentJoint(self): return _Physics.ArticulatedRigidBody_getParentJoint(self)
    def getChildJointCount(self): return _Physics.ArticulatedRigidBody_getChildJointCount(self)
    def getChildJoint(self, *args): return _Physics.ArticulatedRigidBody_getChildJoint(self, *args)
    def isArticulated(self): return _Physics.ArticulatedRigidBody_isArticulated(self)
    def setAFParent(self, *args): return _Physics.ArticulatedRigidBody_setAFParent(self, *args)
    def getAFParent(self): return _Physics.ArticulatedRigidBody_getAFParent(self)
ArticulatedRigidBody_swigregister = _Physics.ArticulatedRigidBody_swigregister
ArticulatedRigidBody_swigregister(ArticulatedRigidBody)

class ArticulatedFigure(Utils.Observable):
    __swig_setmethods__ = {}
    for _s in [Utils.Observable]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArticulatedFigure, name, value)
    __swig_getmethods__ = {}
    for _s in [Utils.Observable]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ArticulatedFigure, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _Physics.new_ArticulatedFigure()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _Physics.delete_ArticulatedFigure
    __del__ = lambda self : None;
    def loadIntoWorld(self): return _Physics.ArticulatedFigure_loadIntoWorld(self)
    def setRoot(self, *args): return _Physics.ArticulatedFigure_setRoot(self, *args)
    def getRoot(self): return _Physics.ArticulatedFigure_getRoot(self)
    def addArticulatedRigidBody(self, *args): return _Physics.ArticulatedFigure_addArticulatedRigidBody(self, *args)
    def getArticulatedRigidBody(self, *args): return _Physics.ArticulatedFigure_getArticulatedRigidBody(self, *args)
    def getArticulatedRigidBodyCount(self): return _Physics.ArticulatedFigure_getArticulatedRigidBodyCount(self)
    def setName(self, *args): return _Physics.ArticulatedFigure_setName(self, *args)
    def getName(self): return _Physics.ArticulatedFigure_getName(self)
    def getARBByName(self, *args): return _Physics.ArticulatedFigure_getARBByName(self, *args)
    def addJoint(self, *args): return _Physics.ArticulatedFigure_addJoint(self, *args)
    def fixJointConstraints(self, fixOrientations = True, fixVelocities = False): return _Physics.ArticulatedFigure_fixJointConstraints(self, fixOrientations, fixVelocities)
    def addJointsToList(self, *args): return _Physics.ArticulatedFigure_addJointsToList(self, *args)
    def computeMass(self): return _Physics.ArticulatedFigure_computeMass(self)
    def getMass(self): return _Physics.ArticulatedFigure_getMass(self)
    def loadFromFile(self, *args): return _Physics.ArticulatedFigure_loadFromFile(self, *args)
    def getJoint(self, *args): return _Physics.ArticulatedFigure_getJoint(self, *args)
    def getJointCount(self): return _Physics.ArticulatedFigure_getJointCount(self)
    def getJointByName(self, *args): return _Physics.ArticulatedFigure_getJointByName(self, *args)
    def getJointIndex(self, *args): return _Physics.ArticulatedFigure_getJointIndex(self, *args)
ArticulatedFigure_swigregister = _Physics.ArticulatedFigure_swigregister
ArticulatedFigure_swigregister(ArticulatedFigure)

class World(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, World, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, World, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_setmethods__["after1000"] = _Physics.World_after1000_set
    __swig_getmethods__["after1000"] = _Physics.World_after1000_get
    if _newclass:after1000 = _swig_property(_Physics.World_after1000_get, _Physics.World_after1000_set)
    __swig_setmethods__["col1000"] = _Physics.World_col1000_set
    __swig_getmethods__["col1000"] = _Physics.World_col1000_get
    if _newclass:col1000 = _swig_property(_Physics.World_col1000_get, _Physics.World_col1000_set)
    __swig_setmethods__["dynamics1000"] = _Physics.World_dynamics1000_set
    __swig_getmethods__["dynamics1000"] = _Physics.World_dynamics1000_get
    if _newclass:dynamics1000 = _swig_property(_Physics.World_dynamics1000_get, _Physics.World_dynamics1000_set)
    __swig_setmethods__["countto1000"] = _Physics.World_countto1000_set
    __swig_getmethods__["countto1000"] = _Physics.World_countto1000_get
    if _newclass:countto1000 = _swig_property(_Physics.World_countto1000_get, _Physics.World_countto1000_set)
    __swig_setmethods__["testmode"] = _Physics.World_testmode_set
    __swig_getmethods__["testmode"] = _Physics.World_testmode_get
    if _newclass:testmode = _swig_property(_Physics.World_testmode_get, _Physics.World_testmode_set)
    __swig_setmethods__["perturb"] = _Physics.World_perturb_set
    __swig_getmethods__["perturb"] = _Physics.World_perturb_get
    if _newclass:perturb = _swig_property(_Physics.World_perturb_get, _Physics.World_perturb_set)
    __swig_setmethods__["nperturb"] = _Physics.World_nperturb_set
    __swig_getmethods__["nperturb"] = _Physics.World_nperturb_get
    if _newclass:nperturb = _swig_property(_Physics.World_nperturb_get, _Physics.World_nperturb_set)
    __swig_getmethods__["instance"] = lambda x: _Physics.World_instance
    if _newclass:instance = staticmethod(_Physics.World_instance)
    def destroyAllObjects(self): return _Physics.World_destroyAllObjects(self)
    def drawRBs(self, flags = 0x0001): return _Physics.World_drawRBs(self, flags)
    def renderRBsToObjFile(self, *args): return _Physics.World_renderRBsToObjFile(self, *args)
    def getContactForces(self): return _Physics.World_getContactForces(self)
    def advanceInTime(self, *args): return _Physics.World_advanceInTime(self, *args)
    __swig_setmethods__["stepCounter"] = _Physics.World_stepCounter_set
    __swig_getmethods__["stepCounter"] = _Physics.World_stepCounter_get
    if _newclass:stepCounter = _swig_property(_Physics.World_stepCounter_get, _Physics.World_stepCounter_set)
    def addStepCounter(self): return _Physics.World_addStepCounter(self)
    def countFrames(self): return _Physics.World_countFrames(self)
    __swig_setmethods__["nbFrames"] = _Physics.World_nbFrames_set
    __swig_getmethods__["nbFrames"] = _Physics.World_nbFrames_get
    if _newclass:nbFrames = _swig_property(_Physics.World_nbFrames_get, _Physics.World_nbFrames_set)
    __swig_setmethods__["height"] = _Physics.World_height_set
    __swig_getmethods__["height"] = _Physics.World_height_get
    if _newclass:height = _swig_property(_Physics.World_height_get, _Physics.World_height_set)
    def addNbFrames(self): return _Physics.World_addNbFrames(self)
    def resetNbFrames(self): return _Physics.World_resetNbFrames(self)
    def getCOMPositions(self): return _Physics.World_getCOMPositions(self)
    __swig_setmethods__["walkcycle"] = _Physics.World_walkcycle_set
    __swig_getmethods__["walkcycle"] = _Physics.World_walkcycle_get
    if _newclass:walkcycle = _swig_property(_Physics.World_walkcycle_get, _Physics.World_walkcycle_set)
    def updateCharacterHeight(self): return _Physics.World_updateCharacterHeight(self)
    def printAllCOMPosition(self): return _Physics.World_printAllCOMPosition(self)
    def loadRBsFromFile(self, *args): return _Physics.World_loadRBsFromFile(self, *args)
    def addRigidBody(self, *args): return _Physics.World_addRigidBody(self, *args)
    def addArticulatedFigure(self, *args): return _Physics.World_addArticulatedFigure(self, *args)
    def getARBByName(self, *args): return _Physics.World_getARBByName(self, *args)
    def getRBByName(self, *args): return _Physics.World_getRBByName(self, *args)
    def getState(self, *args): return _Physics.World_getState(self, *args)
    def setState(self, *args): return _Physics.World_setState(self, *args)
    def getAFCount(self): return _Physics.World_getAFCount(self)
    def getAF(self, *args): return _Physics.World_getAF(self, *args)
    def applyRelForceTo(self, *args): return _Physics.World_applyRelForceTo(self, *args)
    def applyForceTo(self, *args): return _Physics.World_applyForceTo(self, *args)
    def applyTorqueTo(self, *args): return _Physics.World_applyTorqueTo(self, *args)
    def testAdvanceInTime(self, *args): return _Physics.World_testAdvanceInTime(self, *args)
    def runTest(self): return _Physics.World_runTest(self)
    def drawAdditionalInformation(self): return _Physics.World_drawAdditionalInformation(self)
World_swigregister = _Physics.World_swigregister
World_swigregister(World)

def World_instance():
  return _Physics.World_instance()
World_instance = _Physics.World_instance

def world():
	return World_instance();


def castToCollisionDetectionPrimitive(*args):
  return _Physics.castToCollisionDetectionPrimitive(*args)
castToCollisionDetectionPrimitive = _Physics.castToCollisionDetectionPrimitive

def castToBoxCDP(*args):
  return _Physics.castToBoxCDP(*args)
castToBoxCDP = _Physics.castToBoxCDP

def castToSphereCDP(*args):
  return _Physics.castToSphereCDP(*args)
castToSphereCDP = _Physics.castToSphereCDP

def castToPlaneCDP(*args):
  return _Physics.castToPlaneCDP(*args)
castToPlaneCDP = _Physics.castToPlaneCDP

def castToCapsuleCDP(*args):
  return _Physics.castToCapsuleCDP(*args)
castToCapsuleCDP = _Physics.castToCapsuleCDP

def castToJoint(*args):
  return _Physics.castToJoint(*args)
castToJoint = _Physics.castToJoint

def castToStiffJoint(*args):
  return _Physics.castToStiffJoint(*args)
castToStiffJoint = _Physics.castToStiffJoint

def castToHingeJoint(*args):
  return _Physics.castToHingeJoint(*args)
castToHingeJoint = _Physics.castToHingeJoint

def castToUniversalJoint(*args):
  return _Physics.castToUniversalJoint(*args)
castToUniversalJoint = _Physics.castToUniversalJoint

def castToBallInSocketJoint(*args):
  return _Physics.castToBallInSocketJoint(*args)
castToBallInSocketJoint = _Physics.castToBallInSocketJoint

def castToRigidBody(*args):
  return _Physics.castToRigidBody(*args)
castToRigidBody = _Physics.castToRigidBody

def castToArticulatedRigidBody(*args):
  return _Physics.castToArticulatedRigidBody(*args)
castToArticulatedRigidBody = _Physics.castToArticulatedRigidBody

def castToArticulatedFigure(*args):
  return _Physics.castToArticulatedFigure(*args)
castToArticulatedFigure = _Physics.castToArticulatedFigure


