Package pybox2d ::
Module Box2D
|
|
1
2
3
4
5
6
7 from sys import version_info
8 if version_info >= (3,0,0):
9 new_instancemethod = lambda func, inst, cls: _Box2D.SWIG_PyInstanceMethod_New(func)
10 else:
11 from new import instancemethod as new_instancemethod
12 if version_info >= (2,6,0):
14 from os.path import dirname
15 import imp
16 try:
17 fp, pathname, description = imp.find_module('_Box2D', [dirname(__file__)])
18 _mod = imp.load_module('_Box2D', fp, pathname, description)
19 finally:
20 if fp is not None: fp.close()
21 return _mod
22 _Box2D = swig_import_helper()
23 del swig_import_helper
24 else:
25 import _Box2D
26 del version_info
27 try:
28 _swig_property = property
29 except NameError:
30 pass
32 if (name == "thisown"): return self.this.own(value)
33 if (name == "this"):
34 if type(value).__name__ == 'SwigPyObject':
35 self.__dict__[name] = value
36 return
37 method = class_type.__swig_setmethods__.get(name,None)
38 if method: return method(self,value)
39 if (not static) or hasattr(self,name):
40 self.__dict__[name] = value
41 else:
42 raise AttributeError("You cannot add attributes to %s" % self)
43
46
48 if (name == "thisown"): return self.this.own()
49 method = class_type.__swig_getmethods__.get(name,None)
50 if method: return method(self)
51 raise AttributeError(name)
52
54 try: strthis = "proxy of " + self.this.__repr__()
55 except: strthis = ""
56 return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
57
58 try:
59 _object = object
60 _newclass = 1
61 except AttributeError:
63 _newclass = 0
64
65
67 def set_attr(self,name,value):
68 if (name == "thisown"): return self.this.own(value)
69 if hasattr(self,name) or (name == "this"):
70 set(self,name,value)
71 else:
72 raise AttributeError("You cannot add attributes to %s" % self)
73 return set_attr
74
75
76 try:
77 import weakref
78 weakref_proxy = weakref.proxy
79 except:
80 weakref_proxy = lambda x: x
81
82
83
85 return _Box2D.__b2PythonJointPointerEquals__(*args)
86 __b2PythonJointPointerEquals__ = _Box2D.__b2PythonJointPointerEquals__
87
89 return _Box2D.__b2PythonBodyPointerEquals__(*args)
90 __b2PythonBodyPointerEquals__ = _Box2D.__b2PythonBodyPointerEquals__
91
93 return _Box2D.__b2PythonShapePointerEquals__(*args)
94 __b2PythonShapePointerEquals__ = _Box2D.__b2PythonShapePointerEquals__
95
97 return _Box2D.__b2PythonControllerPointerEquals__(*args)
98 __b2PythonControllerPointerEquals__ = _Box2D.__b2PythonControllerPointerEquals__
100
129
131 """
132 Fixes: b2Body, b2Shape, b2Joint, b2Controller
133
134 In place of an unpicklable b2Body outside of a world, use a dictionary with
135 an index to the appropriate place in the world.
136 """
137 bodyList, jointList, controllerList=lists
138
139 if isinstance(value, b2Body):
140 value = { 'pickle_type' : 'b2Body', 'body' : bodyList.index(value) }
141 elif isinstance(value, b2Shape):
142 body = value.GetBody()
143 shapeID = body.shapeList.index(value)
144 value = { 'pickle_type' : 'b2Shape', 'body': bodyList.index(body), 'shape' : shapeID}
145 elif isinstance(value, b2Joint):
146 value = { 'pickle_type' : 'b2Joint', 'joint': jointList.index(value) }
147 elif isinstance(value, b2Controller):
148 value = { 'pickle_type' : 'b2Controller', 'controller' : controllerList.index(value)}
149
150 return value
151
152 -def pickle_fix(world, var, func='save', lists=None):
153 """
154 Fix variables so that they may be pickled (or loaded from a pickled state).
155 You cannot save a b2Body by itself, but if passed in with the world, it's possible
156 to pickle it.
157
158 So, be sure to use this on your box2d-related variables before and after pickling.
159
160 e.g.,
161 + Save:
162 my_pickled_vars = box2d.pickle_fix(myworld, my_vars, 'save')
163 pickle.dump([myworld, my_pickled_vars], open(fn, 'wb'))
164
165 + Load
166 world, my_pickled_vars = pickle.load(open(fn, 'rb'))
167 myworld = world._pickle_finalize()
168 my_vars=box2d.pickle_fix(myworld, my_pickled_vars, 'load')
169
170 For an actual implementation of pickling, see the testbed (main test and test_pickle).
171 """
172 if func=='save':
173 fix_function=_pickle_fix_value_save
174 elif func=='load':
175 fix_function=_pickle_fix_value_load
176 else:
177 raise ValueError, 'Expected func in ("save", "load")'
178
179 if not lists:
180
181 lists=[world.bodyList, world.jointList, world.controllerList]
182
183 if isinstance(var, (list, tuple)):
184
185 new_list=[pickle_fix(world, value, func, lists) for value in var]
186 if isinstance(var, tuple):
187
188 new_list=tuple(new_list)
189 return new_list
190 elif isinstance(var, dict):
191 if func=='load' and 'pickle_type' in var:
192
193 return fix_function(lists, var)
194
195
196 new_dict={}
197 for var, value in var.items():
198 new_dict[var]=pickle_fix(world, value, func, lists)
199 return new_dict
200 else:
201
202
203 ret= fix_function(lists, var)
204 return ret
205
206
208 raise b2PickleError, 'Cannot pickle this object. Pickle the typecasted object: object.getAsType()'
209
210
212 """
213 Takes each variable=value pair in the dictionary and
214 sets the attributes based on them
215 """
216 self.__init__()
217 for key, value in dict.iteritems():
218 setattr(self, key, value)
219
221 """
222 Returns a dictionary representation of self, with
223 dict(var=value [, ...])
224
225 additional_ignore can be specified to ignore certain
226 properties.
227 """
228 ignore_properties = ['thisown', 'this', 'next', 'prev',
229 'world', 'coreVertices', 'normals']
230 if additional_ignore:
231 ignore_properties += additional_ignore
232
233 vars = [v for v in dir(self.__class__)
234 if isinstance(getattr(self.__class__, v), property)
235 and v not in ignore_properties]
236 return dict((var, getattr(self, var)) for var in vars)
237
238
240 """
241 The factory output cannot be created just yet,
242 so store the necessary information to create it later.
243 """
244 self.__pickle_data__ = data
245
246
248 """
249 Finalize one of the outputs that we previously set as a
250 dictionary.
251 """
252 if not hasattr(self, '__pickle_data__'):
253 raise b2PickleError, "Invalid object passed to _pickle_finalize"
254
255
256
257
258
259 data = self.__pickle_data__
260
261
262
263 pairs = [ (lambda w,b,v: w.CreateBody(v) , b2Body , b2BodyDef),
264 (lambda w,b,v: b.CreateShape(v), b2PolygonShape, b2PolygonDef),
265 (lambda w,b,v: b.CreateShape(v), b2CircleShape , b2CircleDef),
266 (lambda w,b,v: b.CreateShape(v), b2EdgeChainDef, b2EdgeChainDef),
267 ]
268
269 createfcn = None
270
271
272
273 for fcn, output, input in pairs:
274 if isinstance(self, output):
275 self = input()
276 createfcn=fcn
277 break
278
279 if not createfcn:
280 raise b2PickleError, "Invalid object passed to _pickle_finalize"
281
282
283
284
285 do_after_classes=(b2Body, b2Shape, list)
286 do_after_props =['linearVelocity', 'angularVelocity', 'isSleeping']
287 finalize_after = []
288
289 if isinstance(self, (b2PolygonDef, b2EdgeChainDef)):
290
291
292 self.vertices = data['vertices']
293 del data['vertices']
294
295 for var in data:
296 value = data[var]
297 if isinstance(value, do_after_classes) or var in do_after_props:
298
299 finalize_after.append( (var, value) )
300 elif hasattr(self, var):
301 setattr(self, var, value)
302
303
304 self = createfcn(world, body, self)
305
306
307
308 if isinstance(self, b2Body):
309 body = self
310
311 for var, value in finalize_after:
312 if var == 'shapeList':
313
314 _pickle_finalize_shapelist(world, body, value)
315 elif var == 'isSleeping':
316
317 if value:
318 self.PutToSleep()
319 else:
320 self.WakeUp()
321 elif hasattr(self, var):
322
323 if hasattr(value, '_pickle_finalize'):
324
325 value=_pickle_finalize(value,world,body)
326 setattr(self, var, value)
327
328 return self
329
330
356
358 """
359 Finalize a joint.
360 The bodies and joints need to be retrieved from the world list
361 in order to make the joint.
362 """
363
364 defn = globals()["b2%sJointDef" % data['_type']] ()
365
366 body_names = ['body1' , 'body2' ]
367 joint_names = ['joint1', 'joint2']
368
369 bodyList = world.bodyList
370 jointList = world.jointList
371
372 for var in data:
373 value = data[var]
374
375 if var=='localXAxis1':
376 var = 'localAxis1'
377
378 if not hasattr(defn, var):
379 continue
380
381 if var in body_names:
382
383 try:
384 value = bodyList[ int(value) ]
385 except:
386 raise b2PickleError, 'World not initialized properly; unable to create joint'
387 elif var in joint_names:
388
389 try:
390 value = jointList[ int(value) ]
391 except:
392 raise b2PickleError, 'World not initialized properly; unable to create joint'
393
394
395 setattr(defn, var, value)
396
397 return world.CreateJoint(defn)
398
400 """
401 Finalize the shape list for a body.
402 Only reason this has to be implemented separately is because of the
403 way edge chains are implemented.
404 """
405 for s in shapelist:
406 if isinstance(s, dict):
407
408
409 temp=b2EdgeChainDef()
410 temp.__pickle_data__=s
411 _pickle_finalize(temp, world, body)
412 else:
413 s._pickle_finalize(world, body)
414
416 """
417 Finalize a b2World.
418 """
419 if not hasattr(self, '__pickle_data__'):
420 raise b2PickleError, 'Finalizing a world that was not loaded?'
421
422 data = self.__pickle_data__
423
424
425 world = b2World(data['worldAABB'], data['gravity'], data['doSleep'])
426
427
428
429
430 gb_data = data['groundBody'].__pickle_data__
431
432
433 _pickle_finalize_shapelist(world, world.groundBody, gb_data['shapeList'])
434
435
436 for var in gb_data.keys():
437 value = gb_data[var]
438 if isinstance(value, (b2Shape)) or var=='shapeList':
439 pass
440 elif hasattr(world.groundBody, var):
441 try:
442 setattr(world.groundBody, var, value)
443 except AttributeError:
444 pass
445
446
447 for body in data['bodyList']:
448 body._pickle_finalize(world)
449
450
451 for joint in data['jointList']:
452 _pickle_finalize_joint(joint, world)
453
454
455 for controller in data['controllerList']:
456 _pickle_finalize_controller(controller, world)
457
458
459 return world
460
462 """
463 Everything is essentially generic_getstate,
464 except for edge shape handling.
465
466 TODO: I can see a possible issue in this if joints are used on
467 an edge shape or a body with edge shapes and other shapes.
468 The shape list order could be improperly recreated. We'll see
469 if anything happens...
470 """
471
472 def get_edge_vertices_and_shapes(shape):
473 """
474 Determine whether or not the edge is a loop.
475 Also, return each shape that this passes through.
476 Then return the vertices.
477
478 Returns is_loop, shapes, vertices
479 """
480
481 vertices = []
482 shapes = []
483 edge = shape
484 while edge:
485 shapes.append(edge)
486 vertices.append( edge.vertex1 )
487 last=edge.vertex2
488
489
490 edge=edge.next
491 if edge==shape:
492 return True, shapes, vertices
493
494
495 vertices.append( last )
496 return False, shapes, vertices
497
498
499 ret = _generic_getstate(self, ['shapeList'])
500
501
502 ret['shapeList']=[]
503 handled_edges = []
504 for shape in self.shapeList:
505 if isinstance(shape, b2EdgeShape):
506 if shape in handled_edges:
507
508
509 continue
510
511 is_loop, shapes, vertices=get_edge_vertices_and_shapes(shape)
512 handled_edges.extend(shapes)
513
514
515
516 shape_info = _generic_getstate(shape, ['vertices','length','coreVertex1','coreVertex2'])
517 shape_info['isALoop'] =is_loop
518 shape_info['vertices']=vertices
519 ret['shapeList'].append(shape_info)
520 else:
521
522 ret['shapeList'].append(shape)
523 return ret
524
552
554 """
555 Get the state of a controller
556 """
557 if not world:
558 raise b2PickleError, "Controllers can't be saved without the world itself"
559
560 ignore_prop =['thisown', 'this', 'bodyList']
561 defn = globals()[ "%sDef" % self.__class__.__name__ ]
562
563
564
565 vars = [v for v in dir(defn)
566 if isinstance(getattr(defn, v), property)
567 and v not in ignore_prop]
568
569 ret=dict((var, getattr(self, var)) for var in vars)
570
571
572 ret['_type'] = self.typeName()
573
574
575
576 main_bodyList = world.bodyList
577 ctrl_bodyList = self.bodyList
578 ret['bodyList']=[main_bodyList.index(body) for body in ctrl_bodyList]
579 return ret
580
582 """
583 Get the state of a joint.
584 """
585 if not world:
586 raise b2PickleError, "Joints can't be saved without the world itself"
587
588
589
590 ignore_prop =['thisown', 'this', 'world', 'type']
591 defn = globals()[ "%sDef" % self.__class__.__name__ ]
592 vars = [v for v in dir(defn)
593 if isinstance(getattr(defn, v), property)
594 and v not in ignore_prop]
595
596
597
598 if 'localAxis1' in vars:
599 vars.remove('localAxis1')
600 vars.append('localXAxis1')
601
602 ret=dict((var, getattr(self, var)) for var in vars)
603 ret['_type'] = self.typeName()
604
605
606 bodyList = world.bodyList
607 jointList= world.jointList
608 for key, value in ret.iteritems():
609 if isinstance(value, b2Body):
610 ret[key]=bodyList.index(value)
611 elif isinstance(value, b2Joint):
612 ret[key]=jointList.index(value)
613
614 return ret
615
616
618 if not isinstance(a, b2Shape) or not isinstance(b, b2Shape):
619 return False
620 return __b2PythonShapePointerEquals__(a, b)
621 -def b2BodyCompare(a, b):
622 if not isinstance(a, b2Body) or not isinstance(b, b2Body):
623 return False
624 return __b2PythonBodyPointerEquals__(a, b)
626 if not isinstance(a, b2Joint) or not isinstance(b, b2Joint):
627 return False
628 return __b2PythonJointPointerEquals__(a, b)
630 if not isinstance(a, b2Controller) or not isinstance(b, b2Controller):
631 return False
632 return __b2PythonControllerPointerEquals__(a, b)
633
634
636 """
637 b2Alloc(int32 size) -> void
638
639 Implement this function to use your own memory allocator.
640 """
641 return _Box2D.b2Alloc(*args)
642
644 """
645 b2Free(void mem)
646
647 If you implement b2Alloc, you should also implement this function.
648 """
649 return _Box2D.b2Free(*args)
651 """Version numbering scheme. See http://en.wikipedia.org/wiki/Software_versioning"""
652 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
653 __repr__ = _swig_repr
654 major = _swig_property(_Box2D.b2Version_major_get, _Box2D.b2Version_major_set)
655 minor = _swig_property(_Box2D.b2Version_minor_get, _Box2D.b2Version_minor_set)
656 revision = _swig_property(_Box2D.b2Version_revision_get, _Box2D.b2Version_revision_set)
658 return """b2Version(
659 major = %s,
660 minor = %s,
661 revision = %s)"""% tuple(str(a) for a in\
662 (self.major,self.minor,self.revision))
663
664 __getstate__=_generic_getstate
665 __setstate__=_generic_setstate
666
668 """__init__(self) -> b2Version"""
669 _Box2D.b2Version_swiginit(self,_Box2D.new_b2Version())
670 __swig_destroy__ = _Box2D.delete_b2Version
671 b2Version_swigregister = _Box2D.b2Version_swigregister
672 b2Version_swigregister(b2Version)
673 cvar = _Box2D.cvar
674 b2_pi = cvar.b2_pi
675 b2_maxManifoldPoints = cvar.b2_maxManifoldPoints
676 b2_maxPolygonVertices = cvar.b2_maxPolygonVertices
677 b2_maxProxies = cvar.b2_maxProxies
678 b2_maxPairs = cvar.b2_maxPairs
679 b2_linearSlop = cvar.b2_linearSlop
680 b2_angularSlop = cvar.b2_angularSlop
681 b2_toiSlop = cvar.b2_toiSlop
682 b2_maxTOIContactsPerIsland = cvar.b2_maxTOIContactsPerIsland
683 b2_maxTOIJointsPerIsland = cvar.b2_maxTOIJointsPerIsland
684 b2_velocityThreshold = cvar.b2_velocityThreshold
685 b2_maxLinearCorrection = cvar.b2_maxLinearCorrection
686 b2_maxAngularCorrection = cvar.b2_maxAngularCorrection
687 b2_maxLinearVelocity = cvar.b2_maxLinearVelocity
688 b2_maxLinearVelocitySquared = cvar.b2_maxLinearVelocitySquared
689 b2_maxAngularVelocity = cvar.b2_maxAngularVelocity
690 b2_maxAngularVelocitySquared = cvar.b2_maxAngularVelocitySquared
691 b2_contactBaumgarte = cvar.b2_contactBaumgarte
692 b2_timeToSleep = cvar.b2_timeToSleep
693 b2_linearSleepTolerance = cvar.b2_linearSleepTolerance
694 b2_angularSleepTolerance = cvar.b2_angularSleepTolerance
695
696
698 """
699 b2MixFriction(float32 friction1, float32 friction2) -> float32
700
701 Friction mixing law. Feel free to customize this.
702 """
703 return _Box2D.b2MixFriction(*args)
704
706 """
707 b2MixRestitution(float32 restitution1, float32 restitution2) -> float32
708
709 Restitution mixing law. Feel free to customize this.
710 """
711 return _Box2D.b2MixRestitution(*args)
712
714 """
715 b2IsValid(float32 x) -> bool
716
717 This function is used to ensure that a floating point number is not a NaN or infinity.
718 """
719 return _Box2D.b2IsValid(*args)
720
722 """
723 b2InvSqrt(float32 x) -> float32
724
725 This is a approximate yet fast inverse square-root.
726 """
727 return _Box2D.b2InvSqrt(*args)
729 """A 2D column vector."""
730 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
731 __repr__ = _swig_repr
733 """
734 SetZero(self)
735
736 Set this vector to all zeros.
737 """
738 return _Box2D.b2Vec2_SetZero(self)
739
740 - def Set(self, *args):
741 """
742 Set(self, float32 x_, float32 y_)
743
744 Set this vector to some specified coordinates.
745 """
746 return _Box2D.b2Vec2_Set(self, *args)
747
749 """__neg__(self) -> b2Vec2"""
750 return _Box2D.b2Vec2___neg__(self)
751
753 """add_vector(self, b2Vec2 v)"""
754 return _Box2D.b2Vec2_add_vector(self, *args)
755
757 """sub_vector(self, b2Vec2 v)"""
758 return _Box2D.b2Vec2_sub_vector(self, *args)
759
761 """mul_float(self, float32 a)"""
762 return _Box2D.b2Vec2_mul_float(self, *args)
763
765 """
766 Length(self) -> float32
767
768 Get the length of this vector (the norm).
769 """
770 return _Box2D.b2Vec2_Length(self)
771
773 """
774 LengthSquared(self) -> float32
775
776 Get the length squared. For performance, use this instead of b2Vec2::Length(if possible).
777 """
778 return _Box2D.b2Vec2_LengthSquared(self)
779
781 """
782 Normalize(self) -> float32
783
784 Convert this vector into a unit vector. Returns the length.
785 """
786 return _Box2D.b2Vec2_Normalize(self)
787
789 """
790 IsValid(self) -> bool
791
792 Does this vector contain finite coordinates?
793 """
794 return _Box2D.b2Vec2_IsValid(self)
795
796 x = _swig_property(_Box2D.b2Vec2_x_get, _Box2D.b2Vec2_x_set)
797 y = _swig_property(_Box2D.b2Vec2_y_get, _Box2D.b2Vec2_y_set)
799 return """b2Vec2(
800 x = %s,
801 y = %s,
802 IsValid() = %s)"""% tuple(str(a) for a in\
803 (self.x,self.y,self.IsValid()))
804
805 __getstate__=_generic_getstate
806 __setstate__=_generic_setstate
807
809 """
810 __init__(self) -> b2Vec2
811 __init__(self, float32 x, float32 y) -> b2Vec2
812 __init__(self, b2Vec2 other) -> b2Vec2
813
814 Construct using coordinates.
815 """
816 _Box2D.b2Vec2_swiginit(self,_Box2D.new_b2Vec2(*args))
818 return "b2Vec2(%g,%g)" % (self.x, self.y)
820 """
821 Return the vector as a tuple (x,y)
822 """
823 return (self.x, self.y)
825 """
826 Set the vector to the values found in the tuple (x,y)
827 You can also use:
828 value = b2Vec2(*tuple)
829 """
830 self.x, self.y = tuple
831 return self
833 """
834 Return a copy of the vector.
835 Remember that the following:
836 a = b2Vec2()
837 b = a
838 Does not copy the vector itself, but b now refers to a.
839 """
840 return b2Vec2(self.x, self.y)
854 """
855 Dot product with v (list/tuple or b2Vec2)
856 """
857 if isinstance(v, (list, tuple)):
858 return self.x*v[0] + self.y*v[1]
859 else:
860 return self.x*v.x + self.y*v.y
861
862
864 """__div__(self, float32 a) -> b2Vec2"""
865 return _Box2D.b2Vec2___div__(self, *args)
866
868 """__mul__(self, float32 a) -> b2Vec2"""
869 return _Box2D.b2Vec2___mul__(self, *args)
870
872 """__add__(self, b2Vec2 other) -> b2Vec2"""
873 return _Box2D.b2Vec2___add__(self, *args)
874
876 """__sub__(self, b2Vec2 other) -> b2Vec2"""
877 return _Box2D.b2Vec2___sub__(self, *args)
878
880 """__rmul__(self, float32 a) -> b2Vec2"""
881 return _Box2D.b2Vec2___rmul__(self, *args)
882
884 """__rdiv__(self, float32 a) -> b2Vec2"""
885 return _Box2D.b2Vec2___rdiv__(self, *args)
886
888 """div_float(self, float32 a)"""
889 return _Box2D.b2Vec2_div_float(self, *args)
890
891 __swig_destroy__ = _Box2D.delete_b2Vec2
892 b2Vec2.SetZero = new_instancemethod(_Box2D.b2Vec2_SetZero,None,b2Vec2)
893 b2Vec2.Set = new_instancemethod(_Box2D.b2Vec2_Set,None,b2Vec2)
894 b2Vec2.__neg__ = new_instancemethod(_Box2D.b2Vec2___neg__,None,b2Vec2)
895 b2Vec2.add_vector = new_instancemethod(_Box2D.b2Vec2_add_vector,None,b2Vec2)
896 b2Vec2.sub_vector = new_instancemethod(_Box2D.b2Vec2_sub_vector,None,b2Vec2)
897 b2Vec2.mul_float = new_instancemethod(_Box2D.b2Vec2_mul_float,None,b2Vec2)
898 b2Vec2.Length = new_instancemethod(_Box2D.b2Vec2_Length,None,b2Vec2)
899 b2Vec2.LengthSquared = new_instancemethod(_Box2D.b2Vec2_LengthSquared,None,b2Vec2)
900 b2Vec2.Normalize = new_instancemethod(_Box2D.b2Vec2_Normalize,None,b2Vec2)
901 b2Vec2.IsValid = new_instancemethod(_Box2D.b2Vec2_IsValid,None,b2Vec2)
902 b2Vec2.__div__ = new_instancemethod(_Box2D.b2Vec2___div__,None,b2Vec2)
903 b2Vec2.__mul__ = new_instancemethod(_Box2D.b2Vec2___mul__,None,b2Vec2)
904 b2Vec2.__add__ = new_instancemethod(_Box2D.b2Vec2___add__,None,b2Vec2)
905 b2Vec2.__sub__ = new_instancemethod(_Box2D.b2Vec2___sub__,None,b2Vec2)
906 b2Vec2.__rmul__ = new_instancemethod(_Box2D.b2Vec2___rmul__,None,b2Vec2)
907 b2Vec2.__rdiv__ = new_instancemethod(_Box2D.b2Vec2___rdiv__,None,b2Vec2)
908 b2Vec2.div_float = new_instancemethod(_Box2D.b2Vec2_div_float,None,b2Vec2)
909 b2Vec2_swigregister = _Box2D.b2Vec2_swigregister
910 b2Vec2_swigregister(b2Vec2)
911
913 """A 2D column vector with 3 elements."""
914 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
915 __repr__ = _swig_repr
917 """
918 __init__(self) -> b2Vec3
919 __init__(self, float32 x, float32 y, float32 z) -> b2Vec3
920
921 Construct using coordinates.
922 """
923 _Box2D.b2Vec3_swiginit(self,_Box2D.new_b2Vec3(*args))
925 """
926 SetZero(self)
927
928 Set this vector to all zeros.
929 """
930 return _Box2D.b2Vec3_SetZero(self)
931
932 - def Set(self, *args):
933 """
934 Set(self, float32 x_, float32 y_, float32 z_)
935
936 Set this vector to some specified coordinates.
937 """
938 return _Box2D.b2Vec3_Set(self, *args)
939
941 """__neg__(self) -> b2Vec3"""
942 return _Box2D.b2Vec3___neg__(self)
943
945 """__iadd__(self, b2Vec3 v)"""
946 return _Box2D.b2Vec3___iadd__(self, *args)
947
949 """__isub__(self, b2Vec3 v)"""
950 return _Box2D.b2Vec3___isub__(self, *args)
951
953 """__imul__(self, float32 s)"""
954 return _Box2D.b2Vec3___imul__(self, *args)
955
956 x = _swig_property(_Box2D.b2Vec3_x_get, _Box2D.b2Vec3_x_set)
957 y = _swig_property(_Box2D.b2Vec3_y_get, _Box2D.b2Vec3_y_set)
958 z = _swig_property(_Box2D.b2Vec3_z_get, _Box2D.b2Vec3_z_set)
960 return """b2Vec3(
961 x = %s,
962 y = %s,
963 z = %s)"""% tuple(str(a) for a in\
964 (self.x,self.y,self.z))
965
966 __getstate__=_generic_getstate
967 __setstate__=_generic_setstate
968
969 __swig_destroy__ = _Box2D.delete_b2Vec3
970 b2Vec3.SetZero = new_instancemethod(_Box2D.b2Vec3_SetZero,None,b2Vec3)
971 b2Vec3.Set = new_instancemethod(_Box2D.b2Vec3_Set,None,b2Vec3)
972 b2Vec3.__neg__ = new_instancemethod(_Box2D.b2Vec3___neg__,None,b2Vec3)
973 b2Vec3.__iadd__ = new_instancemethod(_Box2D.b2Vec3___iadd__,None,b2Vec3)
974 b2Vec3.__isub__ = new_instancemethod(_Box2D.b2Vec3___isub__,None,b2Vec3)
975 b2Vec3.__imul__ = new_instancemethod(_Box2D.b2Vec3___imul__,None,b2Vec3)
976 b2Vec3_swigregister = _Box2D.b2Vec3_swigregister
977 b2Vec3_swigregister(b2Vec3)
978
980 """A 2-by-2 matrix. Stored in column-major order."""
981 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
982 __repr__ = _swig_repr
984 """
985 __init__(self) -> b2Mat22
986 __init__(self, b2Vec2 c1, b2Vec2 c2) -> b2Mat22
987 __init__(self, float32 a11, float32 a12, float32 a21, float32 a22) -> b2Mat22
988 __init__(self, float32 angle) -> b2Mat22
989
990 Construct this matrix using an angle. This matrix becomes an orthonormal rotation matrix.
991 """
992 _Box2D.b2Mat22_swiginit(self,_Box2D.new_b2Mat22(*args))
993 - def Set(self, *args):
994 """
995 Set(self, b2Vec2 c1, b2Vec2 c2)
996 Set(self, float32 angle)
997
998 Initialize this matrix using an angle. This matrix becomes an orthonormal rotation matrix.
999 """
1000 return _Box2D.b2Mat22_Set(self, *args)
1001
1003 """
1004 SetIdentity(self)
1005
1006 Set this to the identity matrix.
1007 """
1008 return _Box2D.b2Mat22_SetIdentity(self)
1009
1011 """
1012 SetZero(self)
1013
1014 Set this matrix to all zeros.
1015 """
1016 return _Box2D.b2Mat22_SetZero(self)
1017
1019 """
1020 GetAngle(self) -> float32
1021
1022 Extract the angle from this matrix (assumed to be a rotation matrix).
1023 """
1024 return _Box2D.b2Mat22_GetAngle(self)
1025
1027 """GetInverse(self) -> b2Mat22"""
1028 return _Box2D.b2Mat22_GetInverse(self)
1029
1030 - def Solve(self, *args):
1031 """
1032 Solve(self, b2Vec2 b) -> b2Vec2
1033
1034 Solve A * x = b, where b is a column vector. This is more efficient than computing the inverse in one-shot cases.
1035 """
1036 return _Box2D.b2Mat22_Solve(self, *args)
1037
1038 col1 = _swig_property(_Box2D.b2Mat22_col1_get, _Box2D.b2Mat22_col1_set)
1039 col2 = _swig_property(_Box2D.b2Mat22_col2_get, _Box2D.b2Mat22_col2_set)
1041 return """b2Mat22(
1042 col1 = %s,
1043 col2 = %s,
1044 GetAngle() = %s)"""% tuple(str(a) for a in\
1045 (self.col1,self.col2,self.GetAngle()))
1046
1047 __getstate__=_generic_getstate
1048 __setstate__=_generic_setstate
1049
1050 __swig_destroy__ = _Box2D.delete_b2Mat22
1051 b2Mat22.Set = new_instancemethod(_Box2D.b2Mat22_Set,None,b2Mat22)
1052 b2Mat22.SetIdentity = new_instancemethod(_Box2D.b2Mat22_SetIdentity,None,b2Mat22)
1053 b2Mat22.SetZero = new_instancemethod(_Box2D.b2Mat22_SetZero,None,b2Mat22)
1054 b2Mat22.GetAngle = new_instancemethod(_Box2D.b2Mat22_GetAngle,None,b2Mat22)
1055 b2Mat22.GetInverse = new_instancemethod(_Box2D.b2Mat22_GetInverse,None,b2Mat22)
1056 b2Mat22.Solve = new_instancemethod(_Box2D.b2Mat22_Solve,None,b2Mat22)
1057 b2Mat22_swigregister = _Box2D.b2Mat22_swigregister
1058 b2Mat22_swigregister(b2Mat22)
1059
1061 """A 3-by-3 matrix. Stored in column-major order."""
1062 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1063 __repr__ = _swig_repr
1065 """
1066 __init__(self) -> b2Mat33
1067 __init__(self, b2Vec3 c1, b2Vec3 c2, b2Vec3 c3) -> b2Mat33
1068
1069 Construct this matrix using columns.
1070 """
1071 _Box2D.b2Mat33_swiginit(self,_Box2D.new_b2Mat33(*args))
1073 """
1074 SetZero(self)
1075
1076 Set this matrix to all zeros.
1077 """
1078 return _Box2D.b2Mat33_SetZero(self)
1079
1081 """
1082 Solve33(self, b2Vec3 b) -> b2Vec3
1083
1084 Solve A * x = b, where b is a column vector. This is more efficient than computing the inverse in one-shot cases.
1085
1086 Solve A * x = b, where b is a column vector. This is more efficient than computing the inverse in one-shot cases.
1087 """
1088 return _Box2D.b2Mat33_Solve33(self, *args)
1089
1091 """
1092 Solve22(self, b2Vec2 b) -> b2Vec2
1093
1094 Solve A * x = b, where b is a column vector. This is more efficient than computing the inverse in one-shot cases. Solve only the upper 2-by-2 matrix equation.
1095
1096 Solve A * x = b, where b is a column vector. This is more efficient than computing the inverse in one-shot cases.
1097 """
1098 return _Box2D.b2Mat33_Solve22(self, *args)
1099
1100 col1 = _swig_property(_Box2D.b2Mat33_col1_get, _Box2D.b2Mat33_col1_set)
1101 col2 = _swig_property(_Box2D.b2Mat33_col2_get, _Box2D.b2Mat33_col2_set)
1102 col3 = _swig_property(_Box2D.b2Mat33_col3_get, _Box2D.b2Mat33_col3_set)
1104 return """b2Mat33(
1105 col1 = %s,
1106 col2 = %s,
1107 col3 = %s)"""% tuple(str(a) for a in\
1108 (self.col1,self.col2,self.col3))
1109
1110 __getstate__=_generic_getstate
1111 __setstate__=_generic_setstate
1112
1113 __swig_destroy__ = _Box2D.delete_b2Mat33
1114 b2Mat33.SetZero = new_instancemethod(_Box2D.b2Mat33_SetZero,None,b2Mat33)
1115 b2Mat33.Solve33 = new_instancemethod(_Box2D.b2Mat33_Solve33,None,b2Mat33)
1116 b2Mat33.Solve22 = new_instancemethod(_Box2D.b2Mat33_Solve22,None,b2Mat33)
1117 b2Mat33_swigregister = _Box2D.b2Mat33_swigregister
1118 b2Mat33_swigregister(b2Mat33)
1119
1139
1140 position = _swig_property(_Box2D.b2XForm_position_get, _Box2D.b2XForm_position_set)
1141 R = _swig_property(_Box2D.b2XForm_R_get, _Box2D.b2XForm_R_set)
1147
1148 __getstate__=_generic_getstate
1149 __setstate__=_generic_setstate
1150
1151 __swig_destroy__ = _Box2D.delete_b2XForm
1152 b2XForm.SetIdentity = new_instancemethod(_Box2D.b2XForm_SetIdentity,None,b2XForm)
1153 b2XForm_swigregister = _Box2D.b2XForm_swigregister
1154 b2XForm_swigregister(b2XForm)
1155
1157 """This describes the motion of a body/shape for TOI computation. Shapes are defined with respect to the body origin, which may no coincide with the center of mass. However, to support dynamics we must interpolate the center of mass position."""
1158 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1159 __repr__ = _swig_repr
1172
1174 """
1175 Advance(self, float32 t)
1176
1177 Advance the sweep forward, yielding a new initial state.
1178
1179 Parameters:
1180 -----------
1181
1182 t: the new initial time.
1183 """
1184 return _Box2D.b2Sweep_Advance(self, *args)
1185
1186 localCenter = _swig_property(_Box2D.b2Sweep_localCenter_get, _Box2D.b2Sweep_localCenter_set)
1187 c0 = _swig_property(_Box2D.b2Sweep_c0_get, _Box2D.b2Sweep_c0_set)
1188 c = _swig_property(_Box2D.b2Sweep_c_get, _Box2D.b2Sweep_c_set)
1189 a0 = _swig_property(_Box2D.b2Sweep_a0_get, _Box2D.b2Sweep_a0_set)
1190 a = _swig_property(_Box2D.b2Sweep_a_get, _Box2D.b2Sweep_a_set)
1191 t0 = _swig_property(_Box2D.b2Sweep_t0_get, _Box2D.b2Sweep_t0_set)
1193 return """b2Sweep(
1194 a = %s,
1195 a0 = %s,
1196 c = %s,
1197 c0 = %s,
1198 localCenter = %s,
1199 t0 = %s)"""% tuple(str(a) for a in\
1200 (self.a,self.a0,self.c,self.c0,self.localCenter,self.t0))
1201
1202 __getstate__=_generic_getstate
1203 __setstate__=_generic_setstate
1204
1206 """__init__(self) -> b2Sweep"""
1207 _Box2D.b2Sweep_swiginit(self,_Box2D.new_b2Sweep())
1208 __swig_destroy__ = _Box2D.delete_b2Sweep
1209 b2Sweep.GetXForm = new_instancemethod(_Box2D.b2Sweep_GetXForm,None,b2Sweep)
1210 b2Sweep.Advance = new_instancemethod(_Box2D.b2Sweep_Advance,None,b2Sweep)
1211 b2Sweep_swigregister = _Box2D.b2Sweep_swigregister
1212 b2Sweep_swigregister(b2Sweep)
1213
1214
1216 """b2equ(b2Vec2 a, b2Vec2 b) -> bool"""
1217 return _Box2D.b2equ(*args)
1218
1220 """b2DistanceSquared(b2Vec2 a, b2Vec2 b) -> float32"""
1221 return _Box2D.b2DistanceSquared(*args)
1222
1224 """b2Min(b2Vec2 a, b2Vec2 b) -> b2Vec2"""
1225 return _Box2D.b2Min(*args)
1226
1228 """b2Max(b2Vec2 a, b2Vec2 b) -> b2Vec2"""
1229 return _Box2D.b2Max(*args)
1230
1232 """b2Clamp(b2Vec2 a, b2Vec2 low, b2Vec2 high) -> b2Vec2"""
1233 return _Box2D.b2Clamp(*args)
1234
1236 """
1237 b2NextPowerOfTwo(uint32 x) -> uint32
1238
1239 "Next Largest Power of 2 Given a binary integer value x, the next largest power of 2 can be computed by a SWAR algorithm that recursively "folds" the upper bits into the lower bits. This process yields a bit vector with the same most significant 1 as x, but all 1's below it. Adding 1 to that value yields the next largest power of 2. For a 32-bit value:"
1240 """
1241 return _Box2D.b2NextPowerOfTwo(*args)
1242
1244 """b2IsPowerOfTwo(uint32 x) -> bool"""
1245 return _Box2D.b2IsPowerOfTwo(*args)
1246 e_unknownJoint = _Box2D.e_unknownJoint
1247 e_revoluteJoint = _Box2D.e_revoluteJoint
1248 e_prismaticJoint = _Box2D.e_prismaticJoint
1249 e_distanceJoint = _Box2D.e_distanceJoint
1250 e_pulleyJoint = _Box2D.e_pulleyJoint
1251 e_mouseJoint = _Box2D.e_mouseJoint
1252 e_gearJoint = _Box2D.e_gearJoint
1253 e_lineJoint = _Box2D.e_lineJoint
1254 e_inactiveLimit = _Box2D.e_inactiveLimit
1255 e_atLowerLimit = _Box2D.e_atLowerLimit
1256 e_atUpperLimit = _Box2D.e_atUpperLimit
1257 e_equalLimits = _Box2D.e_equalLimits
1259 """Proxy of C++ b2Jacobian class"""
1260 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1261 __repr__ = _swig_repr
1262 linear1 = _swig_property(_Box2D.b2Jacobian_linear1_get, _Box2D.b2Jacobian_linear1_set)
1263 angular1 = _swig_property(_Box2D.b2Jacobian_angular1_get, _Box2D.b2Jacobian_angular1_set)
1264 linear2 = _swig_property(_Box2D.b2Jacobian_linear2_get, _Box2D.b2Jacobian_linear2_set)
1265 angular2 = _swig_property(_Box2D.b2Jacobian_angular2_get, _Box2D.b2Jacobian_angular2_set)
1267 """SetZero(self)"""
1268 return _Box2D.b2Jacobian_SetZero(self)
1269
1270 - def Set(self, *args):
1271 """Set(self, b2Vec2 x1, float32 a1, b2Vec2 x2, float32 a2)"""
1272 return _Box2D.b2Jacobian_Set(self, *args)
1273
1275 """Compute(self, b2Vec2 x1, float32 a1, b2Vec2 x2, float32 a2) -> float32"""
1276 return _Box2D.b2Jacobian_Compute(self, *args)
1277
1279 return """b2Jacobian(
1280 angular1 = %s,
1281 angular2 = %s,
1282 linear1 = %s,
1283 linear2 = %s)"""% tuple(str(a) for a in\
1284 (self.angular1,self.angular2,self.linear1,self.linear2))
1285
1286 __getstate__=_generic_getstate
1287 __setstate__=_generic_setstate
1288
1290 """__init__(self) -> b2Jacobian"""
1291 _Box2D.b2Jacobian_swiginit(self,_Box2D.new_b2Jacobian())
1292 __swig_destroy__ = _Box2D.delete_b2Jacobian
1293 b2Jacobian.SetZero = new_instancemethod(_Box2D.b2Jacobian_SetZero,None,b2Jacobian)
1294 b2Jacobian.Set = new_instancemethod(_Box2D.b2Jacobian_Set,None,b2Jacobian)
1295 b2Jacobian.Compute = new_instancemethod(_Box2D.b2Jacobian_Compute,None,b2Jacobian)
1296 b2Jacobian_swigregister = _Box2D.b2Jacobian_swigregister
1297 b2Jacobian_swigregister(b2Jacobian)
1298 b2Vec2_zero = cvar.b2Vec2_zero
1299 b2Mat22_identity = cvar.b2Mat22_identity
1300 b2XForm_identity = cvar.b2XForm_identity
1301
1303 """
1304 b2mul(float32 s, b2Vec2 a) -> b2Vec2
1305 b2mul(float32 s, b2Vec3 a) -> b2Vec3
1306 """
1307 return _Box2D.b2mul(*args)
1308
1310 """
1311 b2sub(b2Vec2 a, b2Vec2 b) -> b2Vec2
1312 b2sub(b2Vec3 a, b2Vec3 b) -> b2Vec3
1313 """
1314 return _Box2D.b2sub(*args)
1315
1317 """
1318 b2Dot(b2Vec2 a, b2Vec2 b) -> float32
1319 b2Dot(b2Vec3 a, b2Vec3 b) -> float32
1320
1321 Perform the dot product on two vectors.
1322 """
1323 return _Box2D.b2Dot(*args)
1324
1326 """
1327 b2Cross(b2Vec2 a, b2Vec2 b) -> float32
1328 b2Cross(b2Vec2 a, float32 s) -> b2Vec2
1329 b2Cross(float32 s, b2Vec2 a) -> b2Vec2
1330 b2Cross(b2Vec3 a, b2Vec3 b) -> b2Vec3
1331
1332 Perform the cross product on two vectors.
1333 """
1334 return _Box2D.b2Cross(*args)
1335
1337 """
1338 b2add(b2Vec2 a, b2Vec2 b) -> b2Vec2
1339 b2add(b2Vec3 a, b2Vec3 b) -> b2Vec3
1340 b2add(b2Mat22 A, b2Mat22 B) -> b2Mat22
1341 """
1342 return _Box2D.b2add(*args)
1343
1345 """
1346 b2Mul(b2Mat22 A, b2Vec2 v) -> b2Vec2
1347 b2Mul(b2Mat22 A, b2Mat22 B) -> b2Mat22
1348 b2Mul(b2Mat33 A, b2Vec3 v) -> b2Vec3
1349 b2Mul(b2XForm T, b2Vec2 v) -> b2Vec2
1350
1351 Multiply a matrix times a vector.
1352 """
1353 return _Box2D.b2Mul(*args)
1354
1356 """
1357 b2MulT(b2Mat22 A, b2Vec2 v) -> b2Vec2
1358 b2MulT(b2Mat22 A, b2Mat22 B) -> b2Mat22
1359 b2MulT(b2XForm T, b2Vec2 v) -> b2Vec2
1360
1361 Multiply a matrix transpose times a vector. If a rotation matrix is provided, then this transforms the vector from one frame to another (inverse transform).
1362 """
1363 return _Box2D.b2MulT(*args)
1364
1366 """
1367 b2Abs(float32 a) -> float32
1368 b2Abs(b2Vec2 a) -> b2Vec2
1369 b2Abs(b2Mat22 A) -> b2Mat22
1370 """
1371 return _Box2D.b2Abs(*args)
1372
1374 """A joint edge is used to connect bodies and joints together in a joint graph where each body is a node and each joint is an edge. A joint edge belongs to a doubly linked list maintained in each attached body. Each joint has two joint nodes, one for each attached body."""
1375 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1376 __repr__ = _swig_repr
1377 other = _swig_property(_Box2D.b2JointEdge_other_get, _Box2D.b2JointEdge_other_set)
1378 joint = _swig_property(_Box2D.b2JointEdge_joint_get, _Box2D.b2JointEdge_joint_set)
1379 prev = _swig_property(_Box2D.b2JointEdge_prev_get, _Box2D.b2JointEdge_prev_set)
1380 next = _swig_property(_Box2D.b2JointEdge_next_get, _Box2D.b2JointEdge_next_set)
1382 return """b2JointEdge(
1383 joint = %s,
1384 other = %s)"""% tuple(str(a) for a in\
1385 (self.joint,self.other))
1386
1387 __getstate__=_generic_getstate
1388 __setstate__=_generic_setstate
1389
1391 """__init__(self) -> b2JointEdge"""
1392 _Box2D.b2JointEdge_swiginit(self,_Box2D.new_b2JointEdge())
1393 __swig_destroy__ = _Box2D.delete_b2JointEdge
1394 b2JointEdge_swigregister = _Box2D.b2JointEdge_swigregister
1395 b2JointEdge_swigregister(b2JointEdge)
1396
1398 """Joint definitions are used to construct joints."""
1399 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1400 __repr__ = _swig_repr
1402 """
1403 __init__(self) -> b2JointDef
1404
1405 Joint definitions are used to construct joints.
1406 """
1407 _Box2D.b2JointDef_swiginit(self,_Box2D.new_b2JointDef())
1408 type = _swig_property(_Box2D.b2JointDef_type_get, _Box2D.b2JointDef_type_set)
1409 body1 = _swig_property(_Box2D.b2JointDef_body1_get, _Box2D.b2JointDef_body1_set)
1410 body2 = _swig_property(_Box2D.b2JointDef_body2_get, _Box2D.b2JointDef_body2_set)
1411 collideConnected = _swig_property(_Box2D.b2JointDef_collideConnected_get, _Box2D.b2JointDef_collideConnected_set)
1413 return """b2JointDef(
1414 body1 = %s,
1415 body2 = %s,
1416 collideConnected = %s,
1417 type = %s,
1418 userData = %s)"""% tuple(str(a) for a in\
1419 (self.body1,self.body2,self.collideConnected,self.type,self.userData))
1420
1421 __getstate__=_generic_getstate
1422 __setstate__=_generic_setstate
1423
1425 """GetUserData(self) -> PyObject"""
1426 return _Box2D.b2JointDef_GetUserData(self)
1427
1429 """SetUserData(self, PyObject data)"""
1430 return _Box2D.b2JointDef_SetUserData(self, *args)
1431
1433 """ClearUserData(self)"""
1434 return _Box2D.b2JointDef_ClearUserData(self)
1435
1436 userData = property(GetUserData, SetUserData)
1439
1441 """
1442 Return the name of the joint from:
1443 Unknown, Mouse, Gear, Distance, Prismatic, Pulley, Revolute
1444 """
1445 types = { e_unknownJoint : "Unknown",
1446 e_mouseJoint : "Mouse",
1447 e_gearJoint : "Gear",
1448 e_distanceJoint : "Distance",
1449 e_prismaticJoint: "Prismatic",
1450 e_pulleyJoint : "Pulley",
1451 e_revoluteJoint : "Revolute" }
1452 return types[self.type]
1453
1454 __swig_destroy__ = _Box2D.delete_b2JointDef
1455 b2JointDef.GetUserData = new_instancemethod(_Box2D.b2JointDef_GetUserData,None,b2JointDef)
1456 b2JointDef.SetUserData = new_instancemethod(_Box2D.b2JointDef_SetUserData,None,b2JointDef)
1457 b2JointDef.ClearUserData = new_instancemethod(_Box2D.b2JointDef_ClearUserData,None,b2JointDef)
1458 b2JointDef_swigregister = _Box2D.b2JointDef_swigregister
1459 b2JointDef_swigregister(b2JointDef)
1460
1462 """The base joint class. Joints are used to constraint two bodies together in various fashions. Some joints also feature limits and motors."""
1463 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1464 - def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
1465 __repr__ = _swig_repr
1467 """
1468 GetType(self) -> b2JointType
1469
1470 Get the type of the concrete joint.
1471 """
1472 return _Box2D.b2Joint_GetType(self)
1473
1474 - def GetBody1(self):
1475 """
1476 GetBody1(self) -> b2Body
1477
1478 Get the first body attached to this joint.
1479 """
1480 return _Box2D.b2Joint_GetBody1(self)
1481
1482 - def GetBody2(self):
1483 """
1484 GetBody2(self) -> b2Body
1485
1486 Get the second body attached to this joint.
1487 """
1488 return _Box2D.b2Joint_GetBody2(self)
1489
1491 """
1492 GetAnchor1(self) -> b2Vec2
1493
1494 Get the anchor point on body1 in world coordinates.
1495 """
1496 return _Box2D.b2Joint_GetAnchor1(self)
1497
1499 """
1500 GetAnchor2(self) -> b2Vec2
1501
1502 Get the anchor point on body2 in world coordinates.
1503 """
1504 return _Box2D.b2Joint_GetAnchor2(self)
1505
1507 """
1508 GetReactionForce(self, float32 inv_dt) -> b2Vec2
1509
1510 Get the reaction force on body2 at the joint anchor.
1511 """
1512 return _Box2D.b2Joint_GetReactionForce(self, *args)
1513
1515 """
1516 GetReactionTorque(self, float32 inv_dt) -> float32
1517
1518 Get the reaction torque on body2.
1519 """
1520 return _Box2D.b2Joint_GetReactionTorque(self, *args)
1521
1523 """
1524 GetNext(self) -> b2Joint
1525
1526 Get the next joint the world joint list.
1527 """
1528 return _Box2D.b2Joint_GetNext(self)
1529
1531 """
1532 GetCollideConnected(self) -> bool
1533
1534 Get whether or not joint bodies can collide.
1535 """
1536 return _Box2D.b2Joint_GetCollideConnected(self)
1537
1539 return """b2Joint(
1540 body1 = %s,
1541 body2 = %s,
1542 collideConnected = %s,
1543 type = %s,
1544 userData = %s,
1545 GetAnchor1() = %s,
1546 GetAnchor2() = %s)"""% tuple(str(a) for a in\
1547 (self.body1,self.body2,self.collideConnected,self.type,self.userData,self.GetAnchor1(),self.GetAnchor2()))
1548
1549 __getstate__=no_pickle
1550 __setstate__=_generic_setstate
1551
1553 """
1554 GetUserData(self) -> PyObject
1555
1556 Get the user data pointer.
1557 """
1558 return _Box2D.b2Joint_GetUserData(self)
1559
1561 """
1562 SetUserData(self, PyObject data)
1563
1564 Set the user data pointer.
1565 """
1566 return _Box2D.b2Joint_SetUserData(self, *args)
1567
1569 """ClearUserData(self)"""
1570 return _Box2D.b2Joint_ClearUserData(self)
1571
1572 userData = property(GetUserData, SetUserData)
1573
1575 """__hash__(self) -> int32"""
1576 return _Box2D.b2Joint___hash__(self)
1577
1578 __eq__ = b2JointCompare
1579 __ne__ = lambda self,other: not b2JointCompare(self,other)
1580 type =property(GetType , None)
1581 body1 =property(GetBody1 , None)
1582 body2 =property(GetBody2 , None)
1583 collideConnected=property(GetCollideConnected, None)
1585 """
1586 Return the name of the joint from:
1587 Unknown, Mouse, Gear, Distance, Prismatic, Pulley, Revolute
1588 """
1589 types = { e_unknownJoint : "Unknown",
1590 e_mouseJoint : "Mouse",
1591 e_gearJoint : "Gear",
1592 e_distanceJoint : "Distance",
1593 e_prismaticJoint: "Prismatic",
1594 e_pulleyJoint : "Pulley",
1595 e_revoluteJoint : "Revolute",
1596 e_lineJoint : "Line" }
1597 return types[self.GetType()]
1599 """
1600 Return a typecasted version of the joint
1601 """
1602 return (getattr(self, "as%sJoint" % self.typeName())) ()
1603
1605 """asMouseJoint(self) -> b2MouseJoint"""
1606 return _Box2D.b2Joint_asMouseJoint(self)
1607
1609 """asGearJoint(self) -> b2GearJoint"""
1610 return _Box2D.b2Joint_asGearJoint(self)
1611
1613 """asDistanceJoint(self) -> b2DistanceJoint"""
1614 return _Box2D.b2Joint_asDistanceJoint(self)
1615
1617 """asPrismaticJoint(self) -> b2PrismaticJoint"""
1618 return _Box2D.b2Joint_asPrismaticJoint(self)
1619
1621 """asPulleyJoint(self) -> b2PulleyJoint"""
1622 return _Box2D.b2Joint_asPulleyJoint(self)
1623
1625 """asRevoluteJoint(self) -> b2RevoluteJoint"""
1626 return _Box2D.b2Joint_asRevoluteJoint(self)
1627
1629 """asLineJoint(self) -> b2LineJoint"""
1630 return _Box2D.b2Joint_asLineJoint(self)
1631
1632 b2Joint.GetType = new_instancemethod(_Box2D.b2Joint_GetType,None,b2Joint)
1633 b2Joint.GetBody1 = new_instancemethod(_Box2D.b2Joint_GetBody1,None,b2Joint)
1634 b2Joint.GetBody2 = new_instancemethod(_Box2D.b2Joint_GetBody2,None,b2Joint)
1635 b2Joint.GetAnchor1 = new_instancemethod(_Box2D.b2Joint_GetAnchor1,None,b2Joint)
1636 b2Joint.GetAnchor2 = new_instancemethod(_Box2D.b2Joint_GetAnchor2,None,b2Joint)
1637 b2Joint.GetReactionForce = new_instancemethod(_Box2D.b2Joint_GetReactionForce,None,b2Joint)
1638 b2Joint.GetReactionTorque = new_instancemethod(_Box2D.b2Joint_GetReactionTorque,None,b2Joint)
1639 b2Joint.GetNext = new_instancemethod(_Box2D.b2Joint_GetNext,None,b2Joint)
1640 b2Joint.GetCollideConnected = new_instancemethod(_Box2D.b2Joint_GetCollideConnected,None,b2Joint)
1641 b2Joint.GetUserData = new_instancemethod(_Box2D.b2Joint_GetUserData,None,b2Joint)
1642 b2Joint.SetUserData = new_instancemethod(_Box2D.b2Joint_SetUserData,None,b2Joint)
1643 b2Joint.ClearUserData = new_instancemethod(_Box2D.b2Joint_ClearUserData,None,b2Joint)
1644 b2Joint.__hash__ = new_instancemethod(_Box2D.b2Joint___hash__,None,b2Joint)
1645 b2Joint.asMouseJoint = new_instancemethod(_Box2D.b2Joint_asMouseJoint,None,b2Joint)
1646 b2Joint.asGearJoint = new_instancemethod(_Box2D.b2Joint_asGearJoint,None,b2Joint)
1647 b2Joint.asDistanceJoint = new_instancemethod(_Box2D.b2Joint_asDistanceJoint,None,b2Joint)
1648 b2Joint.asPrismaticJoint = new_instancemethod(_Box2D.b2Joint_asPrismaticJoint,None,b2Joint)
1649 b2Joint.asPulleyJoint = new_instancemethod(_Box2D.b2Joint_asPulleyJoint,None,b2Joint)
1650 b2Joint.asRevoluteJoint = new_instancemethod(_Box2D.b2Joint_asRevoluteJoint,None,b2Joint)
1651 b2Joint.asLineJoint = new_instancemethod(_Box2D.b2Joint_asLineJoint,None,b2Joint)
1652 b2Joint_swigregister = _Box2D.b2Joint_swigregister
1653 b2Joint_swigregister(b2Joint)
1654
1655
1657 """__b2ComputeCentroid(b2Vec2 vs, int32 count) -> b2Vec2"""
1658 return _Box2D.__b2ComputeCentroid(*args)
1659
1661 """__b2ComputeOBB(b2OBB obb, b2Vec2 vs, int32 count) -> bool"""
1662 return _Box2D.__b2ComputeOBB(*args)
1663 RAND_LIMIT = _Box2D.RAND_LIMIT
1664 B2_FLT_EPSILON = 1.192092896e-07
1665 FLT_EPSILON = B2_FLT_EPSILON
1666 B2_FLT_MAX = 3.402823466e+38
1667 cvars = ('b2_minPulleyLength','b2Contact_s_initialized','b2Contact_s_registers','b2_maxStackEntries','b2_stackSize',
1668 'b2_chunkArrayIncrement','b2_blockSizes','b2_maxBlockSize','b2_chunkSize','b2_defaultFilter','b2BroadPhase_s_validate',
1669 'b2_nullEdge','b2_invalid','b2_tableMask','b2_tableCapacity','b2_nullProxy','b2_nullPair','b2_nullFeature','b2XForm_identity',
1670 'b2Mat22_identity','b2Vec2_zero','b2_version','b2_byteCount','b2_angularSleepTolerance','b2_linearSleepTolerance',
1671 'b2_timeToSleep','b2_contactBaumgarte','b2_maxAngularVelocitySquared','b2_maxAngularVelocity','b2_maxLinearVelocitySquared',
1672 'b2_maxLinearVelocity','b2_maxAngularCorrection','b2_maxLinearCorrection','b2_velocityThreshold','b2_maxTOIJointsPerIsland',
1673 'b2_maxTOIContactsPerIsland','b2_toiSlop','b2_angularSlop','b2_linearSlop','b2_maxPairs','b2_maxProxies','b2_maxPolygonVertices',
1674 'b2_maxManifoldPoints','b2_pi')
1675
1677 """
1678 Computes the centroid of the polygon shape definition, pd.
1679 Raises ValueError on an invalid vertex count or a small area.
1680
1681 Ported from the Box2D C++ code.
1682 """
1683 count = pd.vertexCount
1684
1685 if count < 3:
1686 raise ValueError, "ComputeCentroid: vertex count < 3"
1687
1688 c = b2Vec2(0.0, 0.0)
1689 area = 0.0
1690
1691
1692
1693 pRef = b2Vec2(0.0, 0.0)
1694
1695 inv3 = 1.0 / 3.0
1696
1697 for i in range(count):
1698
1699 p1 = pRef
1700 p2 = pd.getVertex(i)
1701 if i + 1 < count:
1702 p3 = pd.getVertex(i+1)
1703 else: p3 = pd.getVertex(0)
1704
1705 e1 = p2 - p1
1706 e2 = p3 - p1
1707
1708 D = b2Cross(e1, e2)
1709
1710 triangleArea = 0.5 * D
1711 area += triangleArea
1712
1713
1714 c += triangleArea * inv3 * (p1 + p2 + p3)
1715
1716
1717 if area <= FLT_EPSILON:
1718 raise ValueError, "ComputeCentroid: area <= FLT_EPSILON"
1719
1720 return c / area
1721
1722
1724 """
1725 collideCircleParticle(b2CircleShape circle, b2Vec2 ppos) -> PyObject
1726
1727 For liquid simulation. Checks if a particle
1728 would collide with the specified circle.
1729
1730 """
1731 return _Box2D.collideCircleParticle(*args)
1732
1734 """
1735 b2CollidePolyParticle(b2PolygonShape polygon, b2Vec2 ppos, float32 pradius) -> PyObject
1736
1737 For liquid simulation. Checks if a particle
1738 would collide with the specified polygon.
1739
1740 """
1741 return _Box2D.b2CollidePolyParticle(*args)
1743 """
1744 Checks the Polygon definition to see if upon creation it will cause an assertion.
1745 Raises ValueError if an assertion would be raised.
1746
1747 Ported from the Box2D C++ code for CreateShape(). The C++ version is now
1748 included as it's more accurate, please use b2CheckPolygonDef instead.
1749 """
1750
1751 if pd.vertexCount < 3 or pd.vertexCount >= b2_maxPolygonVertices:
1752 raise ValueError, "Invalid vertexCount"
1753
1754 threshold = FLT_EPSILON * FLT_EPSILON
1755 verts = pd.getVertices_b2Vec2()
1756 normals = []
1757 v0 = verts[0]
1758 for i in range(pd.vertexCount):
1759 if i == pd.vertexCount-1:
1760 v1 = verts[0]
1761 else: v1 = verts[i+1]
1762 edge=v1 - v0
1763 if edge.LengthSquared() < threshold:
1764 raise ValueError, "edge.LengthSquared < FLT_EPSILON**2"
1765 normals.append( b2Cross(edge, 1.0) )
1766 normals[-1].Normalize()
1767 v0=v1
1768
1769 centroid = b2PythonComputeCentroid(pd)
1770
1771 d=b2Vec2()
1772 for i in range(pd.vertexCount):
1773 i1 = i - 1
1774 if i1 < 0: i1 = pd.vertexCount - 1
1775 i2 = i
1776 n1 = normals[i1]
1777 n2 = normals[i2]
1778 v = verts[i] - centroid
1779
1780 d.x = b2Dot(n1, v) - b2_toiSlop
1781 d.y = b2Dot(n2, v) - b2_toiSlop
1782
1783
1784
1785
1786
1787 if d.x < 0.0 or d.y <= 0.0:
1788 raise ValueError, "Your shape has a radius/extent less than b2_toiSlop."
1789
1790 A = b2Mat22()
1791 A.col1.x = n1.x; A.col2.x = n1.y
1792 A.col1.y = n2.x; A.col2.y = n2.y
1793
1794
1795 return True
1796
1797
1816 __swig_destroy__ = _Box2D.delete_b2ContactID
1817 b2ContactID_swigregister = _Box2D.b2ContactID_swigregister
1818 b2ContactID_swigregister(b2ContactID)
1819
1821 """
1822 b2Distance(b2Vec2 a, b2Vec2 b) -> float32
1823 b2Distance(b2Shape shape1, b2XForm xf1, b2Shape shape2, b2XForm xf2) -> PyObject
1824
1825 Compute the distance between two shapes and the closest points.
1826 the distance between the shapes or zero if they are overlapped/touching.
1827 """
1828 return _Box2D.b2Distance(*args)
1829
1831 """
1832 b2AABBOverlaps(b2AABB aabb, b2Vec2 point) -> bool
1833 b2AABBOverlaps(b2AABB aabb, b2AABB aabb2) -> bool
1834
1835 Checks if two AABBs overlap, or if a point
1836 lies in an AABB
1837
1838 b2AABBOverlaps(AABB1, [AABB2/point])
1839
1840 """
1841 return _Box2D.b2AABBOverlaps(*args)
1842
1844 """
1845 b2CheckPolygonDef(b2PolygonDef poly, bool additional_checks = True) -> bool
1846 b2CheckPolygonDef(b2PolygonDef poly) -> bool
1847
1848 Checks the Polygon definition to see if upon creation it will cause an assertion.
1849 Raises ValueError if an assertion would be raised.
1850
1851 b2PolygonDef* poly - the polygon definition
1852 bool additional_checks - whether or not to run additional checks
1853
1854 Additional checking: usually only in DEBUG mode on the C++ code.
1855
1856 While shapes that pass this test can be created without assertions,
1857 they will ultimately create unexpected behavior. It's recommended
1858 to _not_ use any polygon that fails this test.
1859
1860 """
1861 return _Box2D.b2CheckPolygonDef(*args)
1862
1864 """
1865 b2Random() -> float32
1866 b2Random(float32 lo, float32 hi) -> float32
1867
1868 Random floating point number in range [lo, hi]. With no arguments, returns one in -1,1.
1869 """
1870 return _Box2D.b2Random(*args)
1871 b2_nullFeature = cvar.b2_nullFeature
1872
1895 __swig_destroy__ = _Box2D.delete_b2ContactID_features
1896 b2ContactID_features_swigregister = _Box2D.b2ContactID_features_swigregister
1897 b2ContactID_features_swigregister(b2ContactID_features)
1898
1900 """A manifold point is a contact point belonging to a contact manifold. It holds details related to the geometry and dynamics of the contact points. The point is stored in local coordinates because CCD requires sub-stepping in which the separation is stale."""
1901 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1902 __repr__ = _swig_repr
1903 localPoint1 = _swig_property(_Box2D.b2ManifoldPoint_localPoint1_get, _Box2D.b2ManifoldPoint_localPoint1_set)
1904 localPoint2 = _swig_property(_Box2D.b2ManifoldPoint_localPoint2_get, _Box2D.b2ManifoldPoint_localPoint2_set)
1905 separation = _swig_property(_Box2D.b2ManifoldPoint_separation_get, _Box2D.b2ManifoldPoint_separation_set)
1906 normalImpulse = _swig_property(_Box2D.b2ManifoldPoint_normalImpulse_get, _Box2D.b2ManifoldPoint_normalImpulse_set)
1907 tangentImpulse = _swig_property(_Box2D.b2ManifoldPoint_tangentImpulse_get, _Box2D.b2ManifoldPoint_tangentImpulse_set)
1908 id = _swig_property(_Box2D.b2ManifoldPoint_id_get, _Box2D.b2ManifoldPoint_id_set)
1910 return """b2ManifoldPoint(
1911 id = %s,
1912 localPoint1 = %s,
1913 localPoint2 = %s,
1914 normalImpulse = %s,
1915 separation = %s,
1916 tangentImpulse = %s)"""% tuple(str(a) for a in\
1917 (self.id,self.localPoint1,self.localPoint2,self.normalImpulse,self.separation,self.tangentImpulse))
1918
1919 __getstate__=_generic_getstate
1920 __setstate__=_generic_setstate
1921
1923 """__init__(self) -> b2ManifoldPoint"""
1924 _Box2D.b2ManifoldPoint_swiginit(self,_Box2D.new_b2ManifoldPoint())
1925 __swig_destroy__ = _Box2D.delete_b2ManifoldPoint
1926 b2ManifoldPoint_swigregister = _Box2D.b2ManifoldPoint_swigregister
1927 b2ManifoldPoint_swigregister(b2ManifoldPoint)
1928
1930 """A manifold for two touching convex shapes."""
1931 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1932 __repr__ = _swig_repr
1933 points = _swig_property(_Box2D.b2Manifold_points_get, _Box2D.b2Manifold_points_set)
1934 normal = _swig_property(_Box2D.b2Manifold_normal_get, _Box2D.b2Manifold_normal_set)
1935 pointCount = _swig_property(_Box2D.b2Manifold_pointCount_get, _Box2D.b2Manifold_pointCount_set)
1937 return """b2Manifold(
1938 normal = %s,
1939 pointCount = %s,
1940 points = %s)"""% tuple(str(a) for a in\
1941 (self.normal,self.pointCount,self.points))
1942
1943 __getstate__=_generic_getstate
1944 __setstate__=_generic_setstate
1945
1947 """__init__(self) -> b2Manifold"""
1948 _Box2D.b2Manifold_swiginit(self,_Box2D.new_b2Manifold())
1949 __swig_destroy__ = _Box2D.delete_b2Manifold
1950 b2Manifold_swigregister = _Box2D.b2Manifold_swigregister
1951 b2Manifold_swigregister(b2Manifold)
1952
1954 """A line segment."""
1955 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1956 __repr__ = _swig_repr
1958 """
1959 TestSegment(self, float32 _lambda, b2Vec2 normal, b2Segment segment,
1960 float32 maxLambda) -> bool
1961
1962 Ray cast against this segment with another segment.
1963 """
1964 return _Box2D.b2Segment_TestSegment(self, *args)
1965
1966 p1 = _swig_property(_Box2D.b2Segment_p1_get, _Box2D.b2Segment_p1_set)
1967 p2 = _swig_property(_Box2D.b2Segment_p2_get, _Box2D.b2Segment_p2_set)
1969 return """b2Segment(
1970 p1 = %s,
1971 p2 = %s)"""% tuple(str(a) for a in\
1972 (self.p1,self.p2))
1973
1974 __getstate__=_generic_getstate
1975 __setstate__=_generic_setstate
1976
1978 """__init__(self) -> b2Segment"""
1979 _Box2D.b2Segment_swiginit(self,_Box2D.new_b2Segment())
1980 __swig_destroy__ = _Box2D.delete_b2Segment
1981 b2Segment.TestSegment = new_instancemethod(_Box2D.b2Segment_TestSegment,None,b2Segment)
1982 b2Segment_swigregister = _Box2D.b2Segment_swigregister
1983 b2Segment_swigregister(b2Segment)
1984
1986 """An axis aligned bounding box."""
1987 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
1988 __repr__ = _swig_repr
1990 """
1991 IsValid(self) -> bool
1992
1993 Verify that the bounds are sorted.
1994 """
1995 return _Box2D.b2AABB_IsValid(self)
1996
1997 lowerBound = _swig_property(_Box2D.b2AABB_lowerBound_get, _Box2D.b2AABB_lowerBound_set)
1998 upperBound = _swig_property(_Box2D.b2AABB_upperBound_get, _Box2D.b2AABB_upperBound_set)
2005
2006 __getstate__=_generic_getstate
2007 __setstate__=_generic_setstate
2008
2010 """__init__(self) -> b2AABB"""
2011 _Box2D.b2AABB_swiginit(self,_Box2D.new_b2AABB())
2012 __swig_destroy__ = _Box2D.delete_b2AABB
2013 b2AABB.IsValid = new_instancemethod(_Box2D.b2AABB_IsValid,None,b2AABB)
2014 b2AABB_swigregister = _Box2D.b2AABB_swigregister
2015 b2AABB_swigregister(b2AABB)
2016
2018 """An oriented bounding box."""
2019 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2020 __repr__ = _swig_repr
2021 R = _swig_property(_Box2D.b2OBB_R_get, _Box2D.b2OBB_R_set)
2022 center = _swig_property(_Box2D.b2OBB_center_get, _Box2D.b2OBB_center_set)
2023 extents = _swig_property(_Box2D.b2OBB_extents_get, _Box2D.b2OBB_extents_set)
2025 return """b2OBB(
2026 R = %s,
2027 center = %s,
2028 extents = %s)"""% tuple(str(a) for a in\
2029 (self.R,self.center,self.extents))
2030
2031 __getstate__=_generic_getstate
2032 __setstate__=_generic_setstate
2033
2035 """__init__(self) -> b2OBB"""
2036 _Box2D.b2OBB_swiginit(self,_Box2D.new_b2OBB())
2037 __swig_destroy__ = _Box2D.delete_b2OBB
2038 b2OBB_swigregister = _Box2D.b2OBB_swigregister
2039 b2OBB_swigregister(b2OBB)
2040
2041
2043 """
2044 b2CollideCircles(b2Manifold manifold, b2CircleShape circle1, b2XForm xf1,
2045 b2CircleShape circle2, b2XForm xf2)
2046
2047 Compute the collision manifold between two circles.
2048 """
2049 return _Box2D.b2CollideCircles(*args)
2050
2052 """
2053 b2CollidePolygonAndCircle(b2Manifold manifold, b2PolygonShape polygon, b2XForm xf1,
2054 b2CircleShape circle, b2XForm xf2)
2055
2056 Compute the collision manifold between a polygon and a circle.
2057 """
2058 return _Box2D.b2CollidePolygonAndCircle(*args)
2059
2061 """
2062 b2CollidePolygons(b2Manifold manifold, b2PolygonShape polygon1, b2XForm xf1,
2063 b2PolygonShape polygon2, b2XForm xf2)
2064
2065 Compute the collision manifold between two circles.
2066 """
2067 return _Box2D.b2CollidePolygons(*args)
2068
2070 """
2071 __b2Distance__(b2Vec2 x1, b2Vec2 x2, b2Shape shape1, b2XForm xf1,
2072 b2Shape shape2, b2XForm xf2) -> float32
2073
2074 Compute the distance between two shapes and the closest points.
2075 the distance between the shapes or zero if they are overlapped/touching.
2076 """
2077 return _Box2D.__b2Distance__(*args)
2078
2080 """
2081 b2TimeOfImpact(b2Shape shape1, b2Sweep sweep1, b2Shape shape2, b2Sweep sweep2) -> float32
2082
2083 Compute the time when two shapes begin to touch or touch at a closer distance.
2084 WARNING:
2085 the sweeps must have the same time interval.
2086
2087 the fraction between [0,1] in which the shapes first touch. fraction=0 means the shapes begin touching/overlapped, and fraction=1 means the shapes don't touch.
2088 """
2089 return _Box2D.b2TimeOfImpact(*args)
2090
2092 """b2TestOverlap(b2AABB a, b2AABB b) -> bool"""
2093 return _Box2D.b2TestOverlap(*args)
2095 """This holds the mass data computed for a shape."""
2096 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2097 __repr__ = _swig_repr
2098 mass = _swig_property(_Box2D.b2MassData_mass_get, _Box2D.b2MassData_mass_set)
2099 center = _swig_property(_Box2D.b2MassData_center_get, _Box2D.b2MassData_center_set)
2100 I = _swig_property(_Box2D.b2MassData_I_get, _Box2D.b2MassData_I_set)
2102 return """b2MassData(
2103 I = %s,
2104 center = %s,
2105 mass = %s)"""% tuple(str(a) for a in\
2106 (self.I,self.center,self.mass))
2107
2108 __getstate__=_generic_getstate
2109 __setstate__=_generic_setstate
2110
2112 """__init__(self) -> b2MassData"""
2113 _Box2D.b2MassData_swiginit(self,_Box2D.new_b2MassData())
2114 __swig_destroy__ = _Box2D.delete_b2MassData
2115 b2MassData_swigregister = _Box2D.b2MassData_swigregister
2116 b2MassData_swigregister(b2MassData)
2117
2119 """This holds contact filtering data."""
2120 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2121 __repr__ = _swig_repr
2122 categoryBits = _swig_property(_Box2D.b2FilterData_categoryBits_get, _Box2D.b2FilterData_categoryBits_set)
2123 maskBits = _swig_property(_Box2D.b2FilterData_maskBits_get, _Box2D.b2FilterData_maskBits_set)
2124 groupIndex = _swig_property(_Box2D.b2FilterData_groupIndex_get, _Box2D.b2FilterData_groupIndex_set)
2131
2132 __getstate__=_generic_getstate
2133 __setstate__=_generic_setstate
2134
2136 """__init__(self) -> b2FilterData"""
2137 _Box2D.b2FilterData_swiginit(self,_Box2D.new_b2FilterData())
2138 __swig_destroy__ = _Box2D.delete_b2FilterData
2139 b2FilterData_swigregister = _Box2D.b2FilterData_swigregister
2140 b2FilterData_swigregister(b2FilterData)
2141
2142 e_unknownShape = _Box2D.e_unknownShape
2143 e_circleShape = _Box2D.e_circleShape
2144 e_polygonShape = _Box2D.e_polygonShape
2145 e_edgeShape = _Box2D.e_edgeShape
2146 e_shapeTypeCount = _Box2D.e_shapeTypeCount
2147 e_startsInsideCollide = _Box2D.e_startsInsideCollide
2148 e_missCollide = _Box2D.e_missCollide
2149 e_hitCollide = _Box2D.e_hitCollide
2151 """A shape definition is used to construct a shape. This class defines an abstract shape definition. You can reuse shape definitions safely."""
2152 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2153 __repr__ = _swig_repr
2155 """
2156 __init__(self) -> b2ShapeDef
2157
2158 The constructor sets the default shape definition values.
2159 """
2160 _Box2D.b2ShapeDef_swiginit(self,_Box2D.new_b2ShapeDef())
2161 __swig_destroy__ = _Box2D.delete_b2ShapeDef
2162 type = _swig_property(_Box2D.b2ShapeDef_type_get, _Box2D.b2ShapeDef_type_set)
2163 friction = _swig_property(_Box2D.b2ShapeDef_friction_get, _Box2D.b2ShapeDef_friction_set)
2164 restitution = _swig_property(_Box2D.b2ShapeDef_restitution_get, _Box2D.b2ShapeDef_restitution_set)
2165 density = _swig_property(_Box2D.b2ShapeDef_density_get, _Box2D.b2ShapeDef_density_set)
2166 isSensor = _swig_property(_Box2D.b2ShapeDef_isSensor_get, _Box2D.b2ShapeDef_isSensor_set)
2167 filter = _swig_property(_Box2D.b2ShapeDef_filter_get, _Box2D.b2ShapeDef_filter_set)
2169 return """b2ShapeDef(
2170 density = %s,
2171 filter = %s,
2172 friction = %s,
2173 isSensor = %s,
2174 restitution = %s,
2175 type = %s,
2176 userData = %s)"""% tuple(str(a) for a in\
2177 (self.density,self.filter,self.friction,self.isSensor,self.restitution,self.type,self.userData))
2178
2179 __getstate__=_generic_getstate
2180 __setstate__=_generic_setstate
2181
2183 """GetUserData(self) -> PyObject"""
2184 return _Box2D.b2ShapeDef_GetUserData(self)
2185
2187 """SetUserData(self, PyObject data)"""
2188 return _Box2D.b2ShapeDef_SetUserData(self, *args)
2189
2191 """ClearUserData(self)"""
2192 return _Box2D.b2ShapeDef_ClearUserData(self)
2193
2194 userData = property(GetUserData, SetUserData)
2197
2198 b2ShapeDef.GetUserData = new_instancemethod(_Box2D.b2ShapeDef_GetUserData,None,b2ShapeDef)
2199 b2ShapeDef.SetUserData = new_instancemethod(_Box2D.b2ShapeDef_SetUserData,None,b2ShapeDef)
2200 b2ShapeDef.ClearUserData = new_instancemethod(_Box2D.b2ShapeDef_ClearUserData,None,b2ShapeDef)
2201 b2ShapeDef_swigregister = _Box2D.b2ShapeDef_swigregister
2202 b2ShapeDef_swigregister(b2ShapeDef)
2203
2205 """
2206 A shape is used for collision detection. Shapes are created in b2World. You can use shape for collision detection before they are attached to the world.
2207 WARNING:
2208 you cannot reuse shapes.
2209 """
2210 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2211 - def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
2212 __repr__ = _swig_repr
2214 """
2215 GetType(self) -> b2ShapeType
2216
2217 Get the type of this shape. You can use this to down cast to the concrete shape.
2218 the shape type.
2219 """
2220 return _Box2D.b2Shape_GetType(self)
2221
2223 """
2224 IsSensor(self) -> bool
2225
2226 Is this shape a sensor (non-solid)?
2227 the true if the shape is a sensor.
2228 """
2229 return _Box2D.b2Shape_IsSensor(self)
2230
2232 """
2233 SetFilterData(self, b2FilterData filter)
2234
2235 Set the contact filtering data. You must call b2World::Refilterto correct existing contacts/non-contacts.
2236 """
2237 return _Box2D.b2Shape_SetFilterData(self, *args)
2238
2240 """
2241 GetFilterData(self) -> b2FilterData
2242
2243 Get the contact filtering data.
2244 """
2245 return _Box2D.b2Shape_GetFilterData(self)
2246
2247 - def GetBody(self):
2248 """
2249 GetBody(self) -> b2Body
2250
2251 Get the parent body of this shape. This is NULL if the shape is not attached.
2252 the parent body.
2253 """
2254 return _Box2D.b2Shape_GetBody(self)
2255
2257 """
2258 GetNext(self) -> b2Shape
2259
2260 Get the next shape in the parent body's shape list.
2261 the next shape.
2262 """
2263 return _Box2D.b2Shape_GetNext(self)
2264
2266 """
2267 TestPoint(self, b2XForm xf, b2Vec2 p) -> bool
2268
2269 Test a point for containment in this shape. This only works for convex shapes.
2270
2271 Parameters:
2272 -----------
2273
2274 xf: the shape world transform.
2275
2276 p: a point in world coordinates.
2277 """
2278 return _Box2D.b2Shape_TestPoint(self, *args)
2279
2281 """
2282 ComputeAABB(self, b2AABB aabb, b2XForm xf)
2283
2284 Given a transform, compute the associated axis aligned bounding box for this shape.
2285
2286 Parameters:
2287 -----------
2288
2289 aabb: returns the axis aligned box.
2290
2291 xf: the world transform of the shape.
2292 """
2293 return _Box2D.b2Shape_ComputeAABB(self, *args)
2294
2296 """
2297 ComputeSweptAABB(self, b2AABB aabb, b2XForm xf1, b2XForm xf2)
2298
2299 Given two transforms, compute the associated swept axis aligned bounding box for this shape.
2300
2301 Parameters:
2302 -----------
2303
2304 aabb: returns the axis aligned box.
2305
2306 xf1: the starting shape world transform.
2307
2308 xf2: the ending shape world transform.
2309 """
2310 return _Box2D.b2Shape_ComputeSweptAABB(self, *args)
2311
2313 """
2314 ComputeMass(self, b2MassData massData)
2315
2316 Compute the mass properties of this shape using its dimensions and density. The inertia tensor is computed about the local origin, not the centroid.
2317
2318 Parameters:
2319 -----------
2320
2321 massData: returns the mass data for this shape.
2322 """
2323 return _Box2D.b2Shape_ComputeMass(self, *args)
2324
2326 """
2327 ComputeSubmergedArea(self, b2Vec2 normal, float32 offset, b2XForm xf, b2Vec2 c) -> float32
2328
2329 Compute the volume and centroid of this shape intersected with a half plane
2330
2331 Parameters:
2332 -----------
2333
2334 normal: the surface normal
2335
2336 offset: the surface offset along normal
2337
2338 xf: the shape transform
2339
2340 c: returns the centroid
2341
2342 the total volume less than offset along normal
2343 """
2344 return _Box2D.b2Shape_ComputeSubmergedArea(self, *args)
2345
2347 """
2348 GetSweepRadius(self) -> float32
2349
2350 Get the maximum radius about the parent body's center of mass.
2351 """
2352 return _Box2D.b2Shape_GetSweepRadius(self)
2353
2355 """
2356 GetFriction(self) -> float32
2357
2358 Get the coefficient of friction.
2359 """
2360 return _Box2D.b2Shape_GetFriction(self)
2361
2363 """
2364 SetFriction(self, float32 friction)
2365
2366 Set the coefficient of friction.
2367 """
2368 return _Box2D.b2Shape_SetFriction(self, *args)
2369
2371 """
2372 GetRestitution(self) -> float32
2373
2374 Get the coefficient of restitution.
2375 """
2376 return _Box2D.b2Shape_GetRestitution(self)
2377
2379 """
2380 SetRestitution(self, float32 restitution)
2381
2382 Set the coefficient of restitution.
2383 """
2384 return _Box2D.b2Shape_SetRestitution(self, *args)
2385
2387 """
2388 GetDensity(self) -> float32
2389
2390 Get the density of the shape.
2391 """
2392 return _Box2D.b2Shape_GetDensity(self)
2393
2395 """
2396 SetDensity(self, float32 density)
2397
2398 Set the density of the shape.
2399 """
2400 return _Box2D.b2Shape_SetDensity(self, *args)
2401
2403 return """b2Shape(
2404 density = %s,
2405 filter = %s,
2406 friction = %s,
2407 restitution = %s,
2408 userData = %s,
2409 GetBody() = %s,
2410 GetFilterData() = %s,
2411 GetSweepRadius() = %s,
2412 GetType() = %s,
2413 IsSensor() = %s)"""% tuple(str(a) for a in\
2414 (self.density,self.filter,self.friction,self.restitution,self.userData,self.GetBody(),self.GetFilterData(),self.GetSweepRadius(),self.GetType(),self.IsSensor()))
2415
2416 __getstate__=no_pickle
2417 __setstate__=_generic_setstate
2418
2420 """
2421 GetUserData(self) -> PyObject
2422
2423 Get the user data that was assigned in the shape definition. Use this to store your application specific data.
2424 """
2425 return _Box2D.b2Shape_GetUserData(self)
2426
2428 """
2429 SetUserData(self, PyObject data)
2430
2431 Set the user data. Use this to store your application specific data.
2432 """
2433 return _Box2D.b2Shape_SetUserData(self, *args)
2434
2436 """ClearUserData(self)"""
2437 return _Box2D.b2Shape_ClearUserData(self)
2438
2439 userData = property(GetUserData, SetUserData)
2440
2442 """__hash__(self) -> int32"""
2443 return _Box2D.b2Shape___hash__(self)
2444
2446 """
2447 TestSegment(self, b2XForm xf, float32 _lambda, b2Vec2 normal, b2Segment segment,
2448 float32 maxLambda) -> b2SegmentCollide
2449 TestSegment(self, b2XForm xf, b2Segment segment, float32 maxLambda) -> PyObject
2450
2451 Perform a ray cast against this shape.
2452
2453 Parameters:
2454 -----------
2455
2456 xf:
2457 the shape world transform.
2458
2459 lambda:
2460 returns the hit fraction. You can use this to compute the contact point p = (1 - lambda) * segment.p1 + lambda * segment.p2.
2461
2462 normal:
2463 returns the normal at the contact point. If there is no intersection, the normal is not set.
2464
2465 segment:
2466 defines the begin and end point of the ray cast.
2467
2468 maxLambda:
2469 a number typically in the range [0,1].
2470 """
2471 return _Box2D.b2Shape_TestSegment(self, *args)
2472
2473 filter = property(GetFilterData, SetFilterData)
2474 friction = property(GetFriction, SetFriction)
2475 restitution= property(GetRestitution, SetRestitution)
2476 density = property(GetDensity, SetDensity)
2477 isSensor = property(IsSensor, None)
2478 __eq__ = b2ShapeCompare
2479 __ne__ = lambda self,other: not b2ShapeCompare(self,other)
2488 """Return a typecasted version of the shape"""
2489 return (getattr(self, "as%s" % self.typeName())) ()
2490
2492 """asCircle(self) -> b2CircleShape"""
2493 return _Box2D.b2Shape_asCircle(self)
2494
2496 """asPolygon(self) -> b2PolygonShape"""
2497 return _Box2D.b2Shape_asPolygon(self)
2498
2500 """asEdge(self) -> b2EdgeShape"""
2501 return _Box2D.b2Shape_asEdge(self)
2502
2503 b2Shape.GetType = new_instancemethod(_Box2D.b2Shape_GetType,None,b2Shape)
2504 b2Shape.IsSensor = new_instancemethod(_Box2D.b2Shape_IsSensor,None,b2Shape)
2505 b2Shape.SetFilterData = new_instancemethod(_Box2D.b2Shape_SetFilterData,None,b2Shape)
2506 b2Shape.GetFilterData = new_instancemethod(_Box2D.b2Shape_GetFilterData,None,b2Shape)
2507 b2Shape.GetBody = new_instancemethod(_Box2D.b2Shape_GetBody,None,b2Shape)
2508 b2Shape.GetNext = new_instancemethod(_Box2D.b2Shape_GetNext,None,b2Shape)
2509 b2Shape.TestPoint = new_instancemethod(_Box2D.b2Shape_TestPoint,None,b2Shape)
2510 b2Shape.ComputeAABB = new_instancemethod(_Box2D.b2Shape_ComputeAABB,None,b2Shape)
2511 b2Shape.ComputeSweptAABB = new_instancemethod(_Box2D.b2Shape_ComputeSweptAABB,None,b2Shape)
2512 b2Shape.ComputeMass = new_instancemethod(_Box2D.b2Shape_ComputeMass,None,b2Shape)
2513 b2Shape.ComputeSubmergedArea = new_instancemethod(_Box2D.b2Shape_ComputeSubmergedArea,None,b2Shape)
2514 b2Shape.GetSweepRadius = new_instancemethod(_Box2D.b2Shape_GetSweepRadius,None,b2Shape)
2515 b2Shape.GetFriction = new_instancemethod(_Box2D.b2Shape_GetFriction,None,b2Shape)
2516 b2Shape.SetFriction = new_instancemethod(_Box2D.b2Shape_SetFriction,None,b2Shape)
2517 b2Shape.GetRestitution = new_instancemethod(_Box2D.b2Shape_GetRestitution,None,b2Shape)
2518 b2Shape.SetRestitution = new_instancemethod(_Box2D.b2Shape_SetRestitution,None,b2Shape)
2519 b2Shape.GetDensity = new_instancemethod(_Box2D.b2Shape_GetDensity,None,b2Shape)
2520 b2Shape.SetDensity = new_instancemethod(_Box2D.b2Shape_SetDensity,None,b2Shape)
2521 b2Shape.GetUserData = new_instancemethod(_Box2D.b2Shape_GetUserData,None,b2Shape)
2522 b2Shape.SetUserData = new_instancemethod(_Box2D.b2Shape_SetUserData,None,b2Shape)
2523 b2Shape.ClearUserData = new_instancemethod(_Box2D.b2Shape_ClearUserData,None,b2Shape)
2524 b2Shape.__hash__ = new_instancemethod(_Box2D.b2Shape___hash__,None,b2Shape)
2525 b2Shape.TestSegment = new_instancemethod(_Box2D.b2Shape_TestSegment,None,b2Shape)
2526 b2Shape.asCircle = new_instancemethod(_Box2D.b2Shape_asCircle,None,b2Shape)
2527 b2Shape.asPolygon = new_instancemethod(_Box2D.b2Shape_asPolygon,None,b2Shape)
2528 b2Shape.asEdge = new_instancemethod(_Box2D.b2Shape_asEdge,None,b2Shape)
2529 b2Shape_swigregister = _Box2D.b2Shape_swigregister
2530 b2Shape_swigregister(b2Shape)
2531
2533 """This structure is used to build circle shapes."""
2534 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2535 __repr__ = _swig_repr
2537 """
2538 __init__(self) -> b2CircleDef
2539
2540 This structure is used to build circle shapes.
2541 """
2542 _Box2D.b2CircleDef_swiginit(self,_Box2D.new_b2CircleDef())
2543 localPosition = _swig_property(_Box2D.b2CircleDef_localPosition_get, _Box2D.b2CircleDef_localPosition_set)
2544 radius = _swig_property(_Box2D.b2CircleDef_radius_get, _Box2D.b2CircleDef_radius_set)
2546 return """b2CircleDef(
2547 density = %s,
2548 filter = %s,
2549 friction = %s,
2550 isSensor = %s,
2551 localPosition = %s,
2552 radius = %s,
2553 restitution = %s,
2554 type = %s,
2555 userData = %s)"""% tuple(str(a) for a in\
2556 (self.density,self.filter,self.friction,self.isSensor,self.localPosition,self.radius,self.restitution,self.type,self.userData))
2557
2558 __getstate__=_generic_getstate
2559 __setstate__=_generic_setstate
2560
2561 __swig_destroy__ = _Box2D.delete_b2CircleDef
2562 b2CircleDef_swigregister = _Box2D.b2CircleDef_swigregister
2563 b2CircleDef_swigregister(b2CircleDef)
2564
2566 """A circle shape."""
2567 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2568 - def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
2569 __repr__ = _swig_repr
2571 """
2572 GetLocalPosition(self) -> b2Vec2
2573
2574 Get the local position of this circle in its parent body.
2575 """
2576 return _Box2D.b2CircleShape_GetLocalPosition(self)
2577
2579 """
2580 GetRadius(self) -> float32
2581
2582 Get the radius of this circle.
2583 """
2584 return _Box2D.b2CircleShape_GetRadius(self)
2585
2587 return """b2CircleShape(
2588 density = %s,
2589 filter = %s,
2590 friction = %s,
2591 localPosition = %s,
2592 radius = %s,
2593 restitution = %s,
2594 userData = %s,
2595 GetBody() = %s,
2596 GetFilterData() = %s,
2597 GetSweepRadius() = %s,
2598 GetType() = %s,
2599 IsSensor() = %s)"""% tuple(str(a) for a in\
2600 (self.density,self.filter,self.friction,self.localPosition,self.radius,self.restitution,self.userData,self.GetBody(),self.GetFilterData(),self.GetSweepRadius(),self.GetType(),self.IsSensor()))
2601
2602 __getstate__=_generic_getstate
2603 __setstate__=_pickle_factory_set
2604 _pickle_finalize=_pickle_finalize
2605
2606 __eq__ = b2ShapeCompare
2607 __ne__ = lambda self,other: not b2ShapeCompare(self,other)
2608 radius = property(GetRadius, None)
2609 localPosition = property(GetLocalPosition, None)
2610
2611 __swig_destroy__ = _Box2D.delete_b2CircleShape
2612 b2CircleShape.GetLocalPosition = new_instancemethod(_Box2D.b2CircleShape_GetLocalPosition,None,b2CircleShape)
2613 b2CircleShape.GetRadius = new_instancemethod(_Box2D.b2CircleShape_GetRadius,None,b2CircleShape)
2614 b2CircleShape_swigregister = _Box2D.b2CircleShape_swigregister
2615 b2CircleShape_swigregister(b2CircleShape)
2616
2618 """Convex polygon. The vertices must be in CCW order for a right-handed coordinate system with the z-axis coming out of the screen."""
2619 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2620 __repr__ = _swig_repr
2622 """
2623 __init__(self) -> b2PolygonDef
2624
2625 Convex polygon. The vertices must be in CCW order for a right-handed coordinate system with the z-axis coming out of the screen.
2626 """
2627 _Box2D.b2PolygonDef_swiginit(self,_Box2D.new_b2PolygonDef())
2629 """
2630 SetAsBox(self, float32 hx, float32 hy)
2631 SetAsBox(self, float32 hx, float32 hy, b2Vec2 center, float32 angle)
2632
2633 Build vertices to represent an oriented box.
2634
2635 Parameters:
2636 -----------
2637
2638 hx: the half-width.
2639
2640 hy: the half-height.
2641
2642 center:
2643 the center of the box in local coordinates.
2644
2645 angle:
2646 the rotation of the box in local coordinates.
2647 """
2648 return _Box2D.b2PolygonDef_SetAsBox(self, *args)
2649
2650 vertexCount = _swig_property(_Box2D.b2PolygonDef_vertexCount_get, _Box2D.b2PolygonDef_vertexCount_set)
2652 return """b2PolygonDef(
2653 density = %s,
2654 filter = %s,
2655 friction = %s,
2656 isSensor = %s,
2657 restitution = %s,
2658 type = %s,
2659 userData = %s,
2660 vertexCount = %s,
2661 vertices = %s)"""% tuple(str(a) for a in\
2662 (self.density,self.filter,self.friction,self.isSensor,self.restitution,self.type,self.userData,self.vertexCount,self.vertices))
2663
2664 __getstate__=_generic_getstate
2665 __setstate__=_generic_setstate
2666
2692 setVertices_tuple = setVertices
2693 setVertices_b2Vec2 = setVertices
2694 vertices = property(getVertices_tuple, setVertices)
2695
2696
2698 """getVertex(self, uint16 vnum) -> b2Vec2"""
2699 return _Box2D.b2PolygonDef_getVertex(self, *args)
2700
2702 """
2703 setVertex(self, uint16 vnum, b2Vec2 value)
2704 setVertex(self, uint16 vnum, float32 x, float32 y)
2705 """
2706 return _Box2D.b2PolygonDef_setVertex(self, *args)
2707
2708 __swig_destroy__ = _Box2D.delete_b2PolygonDef
2709 b2PolygonDef.SetAsBox = new_instancemethod(_Box2D.b2PolygonDef_SetAsBox,None,b2PolygonDef)
2710 b2PolygonDef.getVertex = new_instancemethod(_Box2D.b2PolygonDef_getVertex,None,b2PolygonDef)
2711 b2PolygonDef.setVertex = new_instancemethod(_Box2D.b2PolygonDef_setVertex,None,b2PolygonDef)
2712 b2PolygonDef_swigregister = _Box2D.b2PolygonDef_swigregister
2713 b2PolygonDef_swigregister(b2PolygonDef)
2714
2716 """A convex polygon."""
2717 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2718 - def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
2719 __repr__ = _swig_repr
2721 """
2722 GetOBB(self) -> b2OBB
2723
2724 Get the oriented bounding box relative to the parent body.
2725 """
2726 return _Box2D.b2PolygonShape_GetOBB(self)
2727
2729 """
2730 GetCentroid(self) -> b2Vec2
2731
2732 Get local centroid relative to the parent body.
2733 """
2734 return _Box2D.b2PolygonShape_GetCentroid(self)
2735
2737 """
2738 GetVertexCount(self) -> int32
2739
2740 Get the vertex count.
2741 """
2742 return _Box2D.b2PolygonShape_GetVertexCount(self)
2743
2745 """
2746 GetCoreVertices(self) -> b2Vec2
2747
2748 Get the core vertices in local coordinates. These vertices represent a smaller polygon that is used for time of impact computations.
2749 """
2750 return _Box2D.b2PolygonShape_GetCoreVertices(self)
2751
2753 """
2754 GetFirstVertex(self, b2XForm xf) -> b2Vec2
2755
2756 Get the first vertex and apply the supplied transform.
2757 """
2758 return _Box2D.b2PolygonShape_GetFirstVertex(self, *args)
2759
2761 """
2762 Centroid(self, b2XForm xf) -> b2Vec2
2763
2764 Get the centroid and apply the supplied transform.
2765 """
2766 return _Box2D.b2PolygonShape_Centroid(self, *args)
2767
2769 """
2770 Support(self, b2XForm xf, b2Vec2 d) -> b2Vec2
2771
2772 Get the support point in the given world direction. Use the supplied transform.
2773 """
2774 return _Box2D.b2PolygonShape_Support(self, *args)
2775
2777 return """b2PolygonShape(
2778 coreVertices = %s,
2779 density = %s,
2780 filter = %s,
2781 friction = %s,
2782 normals = %s,
2783 restitution = %s,
2784 userData = %s,
2785 vertices = %s,
2786 GetBody() = %s,
2787 GetCentroid() = %s,
2788 GetFilterData() = %s,
2789 GetOBB() = %s,
2790 GetSweepRadius() = %s,
2791 GetType() = %s,
2792 GetVertexCount() = %s,
2793 IsSensor() = %s)"""% tuple(str(a) for a in\
2794 (self.coreVertices,self.density,self.filter,self.friction,self.normals,self.restitution,self.userData,self.vertices,self.GetBody(),self.GetCentroid(),self.GetFilterData(),self.GetOBB(),self.GetSweepRadius(),self.GetType(),self.GetVertexCount(),self.IsSensor()))
2795
2796 __getstate__=_generic_getstate
2797 __setstate__=_pickle_factory_set
2798 _pickle_finalize=_pickle_finalize
2799
2800 __eq__ = b2ShapeCompare
2801 __ne__ = lambda self,other: not b2ShapeCompare(self,other)
2841 """
2842 Iterates over the vertices in the polygon
2843 """
2844 for v in self.vertices:
2845 yield v
2846
2847 vertices = property(getVertices_tuple, None)
2848 coreVertices = property(getCoreVertices_tuple, None)
2849 normals = property(getNormals_tuple, None)
2850
2852 """getVertex(self, uint16 vnum) -> b2Vec2"""
2853 return _Box2D.b2PolygonShape_getVertex(self, *args)
2854
2856 """getCoreVertex(self, uint16 vnum) -> b2Vec2"""
2857 return _Box2D.b2PolygonShape_getCoreVertex(self, *args)
2858
2860 """getNormal(self, uint16 vnum) -> b2Vec2"""
2861 return _Box2D.b2PolygonShape_getNormal(self, *args)
2862
2863 __swig_destroy__ = _Box2D.delete_b2PolygonShape
2864 b2PolygonShape.GetOBB = new_instancemethod(_Box2D.b2PolygonShape_GetOBB,None,b2PolygonShape)
2865 b2PolygonShape.GetCentroid = new_instancemethod(_Box2D.b2PolygonShape_GetCentroid,None,b2PolygonShape)
2866 b2PolygonShape.GetVertexCount = new_instancemethod(_Box2D.b2PolygonShape_GetVertexCount,None,b2PolygonShape)
2867 b2PolygonShape.GetCoreVertices = new_instancemethod(_Box2D.b2PolygonShape_GetCoreVertices,None,b2PolygonShape)
2868 b2PolygonShape.GetFirstVertex = new_instancemethod(_Box2D.b2PolygonShape_GetFirstVertex,None,b2PolygonShape)
2869 b2PolygonShape.Centroid = new_instancemethod(_Box2D.b2PolygonShape_Centroid,None,b2PolygonShape)
2870 b2PolygonShape.Support = new_instancemethod(_Box2D.b2PolygonShape_Support,None,b2PolygonShape)
2871 b2PolygonShape.getVertex = new_instancemethod(_Box2D.b2PolygonShape_getVertex,None,b2PolygonShape)
2872 b2PolygonShape.getCoreVertex = new_instancemethod(_Box2D.b2PolygonShape_getCoreVertex,None,b2PolygonShape)
2873 b2PolygonShape.getNormal = new_instancemethod(_Box2D.b2PolygonShape_getNormal,None,b2PolygonShape)
2874 b2PolygonShape_swigregister = _Box2D.b2PolygonShape_swigregister
2875 b2PolygonShape_swigregister(b2PolygonShape)
2876
2878 """This structure is used to build edge shapes."""
2879 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2880 __repr__ = _swig_repr
2882 """
2883 __init__(self) -> b2EdgeChainDef
2884
2885 This structure is used to build edge shapes.
2886 """
2887 _Box2D.b2EdgeChainDef_swiginit(self,_Box2D.new_b2EdgeChainDef())
2888 vertexCount = _swig_property(_Box2D.b2EdgeChainDef_vertexCount_get, _Box2D.b2EdgeChainDef_vertexCount_set)
2889 isALoop = _swig_property(_Box2D.b2EdgeChainDef_isALoop_get, _Box2D.b2EdgeChainDef_isALoop_set)
2891 return """b2EdgeChainDef(
2892 density = %s,
2893 filter = %s,
2894 friction = %s,
2895 isALoop = %s,
2896 isSensor = %s,
2897 restitution = %s,
2898 type = %s,
2899 userData = %s,
2900 vertexCount = %s,
2901 vertices = %s)"""% tuple(str(a) for a in\
2902 (self.density,self.filter,self.friction,self.isALoop,self.isSensor,self.restitution,self.type,self.userData,self.vertexCount,self.vertices))
2903
2904 __getstate__=_generic_getstate
2905 __setstate__=_generic_setstate
2906
2926 """Sets all of the vertices given a tuple
2927 in the format ( (x1,y1), (x2,y2) ... (xN,yN) )
2928 where each vertex is either a list/tuple/b2Vec2"""
2929 self._allocateVertices(len(vertices))
2930 for i in range(0, self.vertexCount):
2931 self.setVertex(i, vertices[i])
2932 setVertices_tuple = setVertices
2933 setVertices_b2Vec2 = setVertices
2934 vertices = property(getVertices_tuple, setVertices)
2935
2936
2938 """_cleanUp(self)"""
2939 return _Box2D.b2EdgeChainDef__cleanUp(self)
2940
2942 """_allocateVertices(self, uint16 _count)"""
2943 return _Box2D.b2EdgeChainDef__allocateVertices(self, *args)
2944
2946 """getVertex(self, uint16 vnum) -> b2Vec2"""
2947 return _Box2D.b2EdgeChainDef_getVertex(self, *args)
2948
2950 """
2951 setVertex(self, uint16 vnum, b2Vec2 value)
2952 setVertex(self, uint16 vnum, float32 x, float32 y)
2953 """
2954 return _Box2D.b2EdgeChainDef_setVertex(self, *args)
2955
2956 __swig_destroy__ = _Box2D.delete_b2EdgeChainDef
2957 b2EdgeChainDef._cleanUp = new_instancemethod(_Box2D.b2EdgeChainDef__cleanUp,None,b2EdgeChainDef)
2958 b2EdgeChainDef._allocateVertices = new_instancemethod(_Box2D.b2EdgeChainDef__allocateVertices,None,b2EdgeChainDef)
2959 b2EdgeChainDef.getVertex = new_instancemethod(_Box2D.b2EdgeChainDef_getVertex,None,b2EdgeChainDef)
2960 b2EdgeChainDef.setVertex = new_instancemethod(_Box2D.b2EdgeChainDef_setVertex,None,b2EdgeChainDef)
2961 b2EdgeChainDef_swigregister = _Box2D.b2EdgeChainDef_swigregister
2962 b2EdgeChainDef_swigregister(b2EdgeChainDef)
2963
2965 """The edge shape."""
2966 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
2967 - def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
2968 __repr__ = _swig_repr
2970 """
2971 GetLength(self) -> float32
2972
2973 Linear distance from vertex1 to vertex2:.
2974 """
2975 return _Box2D.b2EdgeShape_GetLength(self)
2976
2978 """
2979 GetVertex1(self) -> b2Vec2
2980
2981 Local position of vertex in parent body.
2982 """
2983 return _Box2D.b2EdgeShape_GetVertex1(self)
2984
2986 """
2987 GetVertex2(self) -> b2Vec2
2988
2989 Local position of vertex in parent body.
2990 """
2991 return _Box2D.b2EdgeShape_GetVertex2(self)
2992
2994 """
2995 GetCoreVertex1(self) -> b2Vec2
2996
2997 "Core" vertex with TOI slop for b2Distance functions:
2998 """
2999 return _Box2D.b2EdgeShape_GetCoreVertex1(self)
3000
3002 """
3003 GetCoreVertex2(self) -> b2Vec2
3004
3005 "Core" vertex with TOI slop for b2Distance functions:
3006 """
3007 return _Box2D.b2EdgeShape_GetCoreVertex2(self)
3008
3010 """
3011 GetNormalVector(self) -> b2Vec2
3012
3013 Perpendicular unit vector point, pointing from the solid side to the empty side:.
3014 """
3015 return _Box2D.b2EdgeShape_GetNormalVector(self)
3016
3018 """
3019 GetDirectionVector(self) -> b2Vec2
3020
3021 Parallel unit vector, pointing from vertex1 to vertex2:.
3022 """
3023 return _Box2D.b2EdgeShape_GetDirectionVector(self)
3024
3026 """GetCorner1Vector(self) -> b2Vec2"""
3027 return _Box2D.b2EdgeShape_GetCorner1Vector(self)
3028
3030 """GetCorner2Vector(self) -> b2Vec2"""
3031 return _Box2D.b2EdgeShape_GetCorner2Vector(self)
3032
3034 """Corner1IsConvex(self) -> bool"""
3035 return _Box2D.b2EdgeShape_Corner1IsConvex(self)
3036
3038 """Corner2IsConvex(self) -> bool"""
3039 return _Box2D.b2EdgeShape_Corner2IsConvex(self)
3040
3042 """GetFirstVertex(self, b2XForm xf) -> b2Vec2"""
3043 return _Box2D.b2EdgeShape_GetFirstVertex(self, *args)
3044
3046 """Support(self, b2XForm xf, b2Vec2 d) -> b2Vec2"""
3047 return _Box2D.b2EdgeShape_Support(self, *args)
3048
3050 """
3051 GetNextEdge(self) -> b2EdgeShape
3052
3053 Get the next edge in the chain.
3054 """
3055 return _Box2D.b2EdgeShape_GetNextEdge(self)
3056
3058 """
3059 GetPrevEdge(self) -> b2EdgeShape
3060
3061 Get the previous edge in the chain.
3062 """
3063 return _Box2D.b2EdgeShape_GetPrevEdge(self)
3064
3066 """SetPrevEdge(self, b2EdgeShape edge, b2Vec2 core, b2Vec2 cornerDir, bool convex)"""
3067 return _Box2D.b2EdgeShape_SetPrevEdge(self, *args)
3068
3070 """SetNextEdge(self, b2EdgeShape edge, b2Vec2 core, b2Vec2 cornerDir, bool convex)"""
3071 return _Box2D.b2EdgeShape_SetNextEdge(self, *args)
3072
3074 return """b2EdgeShape(
3075 density = %s,
3076 filter = %s,
3077 friction = %s,
3078 restitution = %s,
3079 userData = %s,
3080 GetBody() = %s,
3081 GetCoreVertex1() = %s,
3082 GetCoreVertex2() = %s,
3083 GetCorner1Vector() = %s,
3084 GetCorner2Vector() = %s,
3085 GetDirectionVector() = %s,
3086 GetFilterData() = %s,
3087 GetLength() = %s,
3088 GetNormalVector() = %s,
3089 GetSweepRadius() = %s,
3090 GetType() = %s,
3091 GetVertex1() = %s,
3092 GetVertex2() = %s,
3093 IsSensor() = %s)"""% tuple(str(a) for a in\
3094 (self.density,self.filter,self.friction,self.restitution,self.userData,self.GetBody(),self.GetCoreVertex1(),self.GetCoreVertex2(),self.GetCorner1Vector(),self.GetCorner2Vector(),self.GetDirectionVector(),self.GetFilterData(),self.GetLength(),self.GetNormalVector(),self.GetSweepRadius(),self.GetType(),self.GetVertex1(),self.GetVertex2(),self.IsSensor()))
3095
3096 __getstate__=_generic_getstate
3097 __setstate__=_pickle_factory_set
3098 _pickle_finalize=_pickle_finalize
3099
3112
3113 length = property(GetLength, None)
3114 vertex1 = property(GetVertex1, None)
3115 vertex2 = property(GetVertex2, None)
3116 coreVertex1 = property(GetCoreVertex1, None)
3117 coreVertex2 = property(GetCoreVertex2, None)
3118 next = property(GetNextEdge, None)
3119 prev = property(GetPrevEdge, None)
3120
3121 __swig_destroy__ = _Box2D.delete_b2EdgeShape
3122 b2EdgeShape.GetLength = new_instancemethod(_Box2D.b2EdgeShape_GetLength,None,b2EdgeShape)
3123 b2EdgeShape.GetVertex1 = new_instancemethod(_Box2D.b2EdgeShape_GetVertex1,None,b2EdgeShape)
3124 b2EdgeShape.GetVertex2 = new_instancemethod(_Box2D.b2EdgeShape_GetVertex2,None,b2EdgeShape)
3125 b2EdgeShape.GetCoreVertex1 = new_instancemethod(_Box2D.b2EdgeShape_GetCoreVertex1,None,b2EdgeShape)
3126 b2EdgeShape.GetCoreVertex2 = new_instancemethod(_Box2D.b2EdgeShape_GetCoreVertex2,None,b2EdgeShape)
3127 b2EdgeShape.GetNormalVector = new_instancemethod(_Box2D.b2EdgeShape_GetNormalVector,None,b2EdgeShape)
3128 b2EdgeShape.GetDirectionVector = new_instancemethod(_Box2D.b2EdgeShape_GetDirectionVector,None,b2EdgeShape)
3129 b2EdgeShape.GetCorner1Vector = new_instancemethod(_Box2D.b2EdgeShape_GetCorner1Vector,None,b2EdgeShape)
3130 b2EdgeShape.GetCorner2Vector = new_instancemethod(_Box2D.b2EdgeShape_GetCorner2Vector,None,b2EdgeShape)
3131 b2EdgeShape.Corner1IsConvex = new_instancemethod(_Box2D.b2EdgeShape_Corner1IsConvex,None,b2EdgeShape)
3132 b2EdgeShape.Corner2IsConvex = new_instancemethod(_Box2D.b2EdgeShape_Corner2IsConvex,None,b2EdgeShape)
3133 b2EdgeShape.GetFirstVertex = new_instancemethod(_Box2D.b2EdgeShape_GetFirstVertex,None,b2EdgeShape)
3134 b2EdgeShape.Support = new_instancemethod(_Box2D.b2EdgeShape_Support,None,b2EdgeShape)
3135 b2EdgeShape.GetNextEdge = new_instancemethod(_Box2D.b2EdgeShape_GetNextEdge,None,b2EdgeShape)
3136 b2EdgeShape.GetPrevEdge = new_instancemethod(_Box2D.b2EdgeShape_GetPrevEdge,None,b2EdgeShape)
3137 b2EdgeShape.SetPrevEdge = new_instancemethod(_Box2D.b2EdgeShape_SetPrevEdge,None,b2EdgeShape)
3138 b2EdgeShape.SetNextEdge = new_instancemethod(_Box2D.b2EdgeShape_SetNextEdge,None,b2EdgeShape)
3139 b2EdgeShape_swigregister = _Box2D.b2EdgeShape_swigregister
3140 b2EdgeShape_swigregister(b2EdgeShape)
3141
3143 """Proxy of C++ b2Pair class"""
3144 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
3145 __repr__ = _swig_repr
3146 e_pairBuffered = _Box2D.b2Pair_e_pairBuffered
3147 e_pairRemoved = _Box2D.b2Pair_e_pairRemoved
3148 e_pairFinal = _Box2D.b2Pair_e_pairFinal
3150 """SetBuffered(self)"""
3151 return _Box2D.b2Pair_SetBuffered(self)
3152
3154 """ClearBuffered(self)"""
3155 return _Box2D.b2Pair_ClearBuffered(self)
3156
3158 """IsBuffered(self) -> bool"""
3159 return _Box2D.b2Pair_IsBuffered(self)
3160
3162 """SetRemoved(self)"""
3163 return _Box2D.b2Pair_SetRemoved(self)
3164
3166 """ClearRemoved(self)"""
3167 return _Box2D.b2Pair_ClearRemoved(self)
3168
3170 """IsRemoved(self) -> bool"""
3171 return _Box2D.b2Pair_IsRemoved(self)
3172
3174 """SetFinal(self)"""
3175 return _Box2D.b2Pair_SetFinal(self)
3176
3178 """IsFinal(self) -> bool"""
3179 return _Box2D.b2Pair_IsFinal(self)
3180
3181 proxyId1 = _swig_property(_Box2D.b2Pair_proxyId1_get, _Box2D.b2Pair_proxyId1_set)
3182 proxyId2 = _swig_property(_Box2D.b2Pair_proxyId2_get, _Box2D.b2Pair_proxyId2_set)
3183 next = _swig_property(_Box2D.b2Pair_next_get, _Box2D.b2Pair_next_set)
3184 status = _swig_property(_Box2D.b2Pair_status_get, _Box2D.b2Pair_status_set)
3186 return """b2Pair(
3187 proxyId1 = %s,
3188 proxyId2 = %s,
3189 status = %s,
3190 userData = %s,
3191 IsBuffered() = %s,
3192 IsFinal() = %s,
3193 IsRemoved() = %s,
3194 e_pairBuffered = %s,
3195 e_pairFinal = %s,
3196 e_pairRemoved = %s)"""% tuple(str(a) for a in\
3197 (self.proxyId1,self.proxyId2,self.status,self.userData,self.IsBuffered(),self.IsFinal(),self.IsRemoved(),self.e_pairBuffered,self.e_pairFinal,self.e_pairRemoved))
3198
3199 __getstate__=_generic_getstate
3200 __setstate__=_generic_setstate
3201
3203 """__init__(self) -> b2Pair"""
3204 _Box2D.b2Pair_swiginit(self,_Box2D.new_b2Pair())
3205 __swig_destroy__ = _Box2D.delete_b2Pair
3206 b2Pair.SetBuffered = new_instancemethod(_Box2D.b2Pair_SetBuffered,None,b2Pair)
3207 b2Pair.ClearBuffered = new_instancemethod(_Box2D.b2Pair_ClearBuffered,None,b2Pair)
3208 b2Pair.IsBuffered = new_instancemethod(_Box2D.b2Pair_IsBuffered,None,b2Pair)
3209 b2Pair.SetRemoved = new_instancemethod(_Box2D.b2Pair_SetRemoved,None,b2Pair)
3210 b2Pair.ClearRemoved = new_instancemethod(_Box2D.b2Pair_ClearRemoved,None,b2Pair)
3211 b2Pair.IsRemoved = new_instancemethod(_Box2D.b2Pair_IsRemoved,None,b2Pair)
3212 b2Pair.SetFinal = new_instancemethod(_Box2D.b2Pair_SetFinal,None,b2Pair)
3213 b2Pair.IsFinal = new_instancemethod(_Box2D.b2Pair_IsFinal,None,b2Pair)
3214 b2Pair_swigregister = _Box2D.b2Pair_swigregister
3215 b2Pair_swigregister(b2Pair)
3216 b2_nullPair = cvar.b2_nullPair
3217 b2_nullProxy = cvar.b2_nullProxy
3218 b2_tableCapacity = cvar.b2_tableCapacity
3219 b2_tableMask = cvar.b2_tableMask
3220
3222 """Proxy of C++ b2BufferedPair class"""
3223 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
3224 __repr__ = _swig_repr
3225 proxyId1 = _swig_property(_Box2D.b2BufferedPair_proxyId1_get, _Box2D.b2BufferedPair_proxyId1_set)
3226 proxyId2 = _swig_property(_Box2D.b2BufferedPair_proxyId2_get, _Box2D.b2BufferedPair_proxyId2_set)
3228 return """b2BufferedPair(
3229 proxyId1 = %s,
3230 proxyId2 = %s)"""% tuple(str(a) for a in\
3231 (self.proxyId1,self.proxyId2))
3232
3233 __getstate__=_generic_getstate
3234 __setstate__=_generic_setstate
3235
3237 """__init__(self) -> b2BufferedPair"""
3238 _Box2D.b2BufferedPair_swiginit(self,_Box2D.new_b2BufferedPair())
3239 __swig_destroy__ = _Box2D.delete_b2BufferedPair
3240 b2BufferedPair_swigregister = _Box2D.b2BufferedPair_swigregister
3241 b2BufferedPair_swigregister(b2BufferedPair)
3242
3244 """Proxy of C++ b2PairCallback class"""
3245 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
3246 - def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
3247 __repr__ = _swig_repr
3248 __swig_destroy__ = _Box2D.delete_b2PairCallback
3250 """PairAdded(self, void proxyUserData1, void proxyUserData2) -> void"""
3251 return _Box2D.b2PairCallback_PairAdded(self, *args)
3252
3254 """PairRemoved(self, void proxyUserData1, void proxyUserData2, void pairUserData)"""
3255 return _Box2D.b2PairCallback_PairRemoved(self, *args)
3256
3258 return "b2PairCallback()"
3259
3260 __getstate__=_generic_getstate
3261 __setstate__=_generic_setstate
3262
3263 b2PairCallback.PairAdded = new_instancemethod(_Box2D.b2PairCallback_PairAdded,None,b2PairCallback)
3264 b2PairCallback.PairRemoved = new_instancemethod(_Box2D.b2PairCallback_PairRemoved,None,b2PairCallback)
3265 b2PairCallback_swigregister = _Box2D.b2PairCallback_swigregister
3266 b2PairCallback_swigregister(b2PairCallback)
3267
3269 """Proxy of C++ b2PairManager class"""
3270 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
3271 __repr__ = _swig_repr
3273 """__init__(self) -> b2PairManager"""
3274 _Box2D.b2PairManager_swiginit(self,_Box2D.new_b2PairManager())
3276 """Initialize(self, b2BroadPhase broadPhase, b2PairCallback callback)"""
3277 return _Box2D.b2PairManager_Initialize(self, *args)
3278
3280 """AddBufferedPair(self, int32 proxyId1, int32 proxyId2)"""
3281 return _Box2D.b2PairManager_AddBufferedPair(self, *args)
3282
3284 """RemoveBufferedPair(self, int32 proxyId1, int32 proxyId2)"""
3285 return _Box2D.b2PairManager_RemoveBufferedPair(self, *args)
3286
3288 """Commit(self)"""
3289 return _Box2D.b2PairManager_Commit(self)
3290
3291 broadPhase = _swig_property(_Box2D.b2PairManager_broadPhase_get, _Box2D.b2PairManager_broadPhase_set)
3292 callback = _swig_property(_Box2D.b2PairManager_callback_get, _Box2D.b2PairManager_callback_set)
3293 pairs = _swig_property(_Box2D.b2PairManager_pairs_get, _Box2D.b2PairManager_pairs_set)
3294 freePair = _swig_property(_Box2D.b2PairManager_freePair_get, _Box2D.b2PairManager_freePair_set)
3295 pairCount = _swig_property(_Box2D.b2PairManager_pairCount_get, _Box2D.b2PairManager_pairCount_set)
3296 pairBuffer = _swig_property(_Box2D.b2PairManager_pairBuffer_get, _Box2D.b2PairManager_pairBuffer_set)
3297 pairBufferCount = _swig_property(_Box2D.b2PairManager_pairBufferCount_get, _Box2D.b2PairManager_pairBufferCount_set)
3298 hashTable = _swig_property(_Box2D.b2PairManager_hashTable_get, _Box2D.b2PairManager_hashTable_set)
3300 return """b2PairManager(
3301 broadPhase = %s,
3302 callback = %s,
3303 freePair = %s,
3304 hashTable = %s,
3305 pairBuffer = %s,
3306 pairBufferCount = %s,
3307 pairCount = %s,
3308 pairs = %s)"""% tuple(str(a) for a in\
3309 (self.broadPhase,self.callback,self.freePair,self.hashTable,self.pairBuffer,self.pairBufferCount,self.pairCount,self.pairs))
3310
3311 __getstate__=_generic_getstate
3312 __setstate__=_generic_setstate
3313
3314 __swig_destroy__ = _Box2D.delete_b2PairManager
3315 b2PairManager.Initialize = new_instancemethod(_Box2D.b2PairManager_Initialize,None,b2PairManager)
3316 b2PairManager.AddBufferedPair = new_instancemethod(_Box2D.b2PairManager_AddBufferedPair,None,b2PairManager)
3317 b2PairManager.RemoveBufferedPair = new_instancemethod(_Box2D.b2PairManager_RemoveBufferedPair,None,b2PairManager)
3318 b2PairManager.Commit = new_instancemethod(_Box2D.b2PairManager_Commit,None,b2PairManager)
3319 b2PairManager_swigregister = _Box2D.b2PairManager_swigregister
3320 b2PairManager_swigregister(b2PairManager)
3321
3323 """Proxy of C++ b2Bound class"""
3324 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
3325 __repr__ = _swig_repr
3327 """IsLower(self) -> bool"""
3328 return _Box2D.b2Bound_IsLower(self)
3329
3331 """IsUpper(self) -> bool"""
3332 return _Box2D.b2Bound_IsUpper(self)
3333
3334 value = _swig_property(_Box2D.b2Bound_value_get, _Box2D.b2Bound_value_set)
3335 proxyId = _swig_property(_Box2D.b2Bound_proxyId_get, _Box2D.b2Bound_proxyId_set)
3336 stabbingCount = _swig_property(_Box2D.b2Bound_stabbingCount_get, _Box2D.b2Bound_stabbingCount_set)
3338 return """b2Bound(
3339 proxyId = %s,
3340 stabbingCount = %s,
3341 value = %s,
3342 IsLower() = %s,
3343 IsUpper() = %s)"""% tuple(str(a) for a in\
3344 (self.proxyId,self.stabbingCount,self.value,self.IsLower(),self.IsUpper()))
3345
3346 __getstate__=_generic_getstate
3347 __setstate__=_generic_setstate
3348
3350 """__init__(self) -> b2Bound"""
3351 _Box2D.b2Bound_swiginit(self,_Box2D.new_b2Bound())
3352 __swig_destroy__ = _Box2D.delete_b2Bound
3353 b2Bound.IsLower = new_instancemethod(_Box2D.b2Bound_IsLower,None,b2Bound)
3354 b2Bound.IsUpper = new_instancemethod(_Box2D.b2Bound_IsUpper,None,b2Bound)
3355 b2Bound_swigregister = _Box2D.b2Bound_swigregister
3356 b2Bound_swigregister(b2Bound)
3357 b2_invalid = cvar.b2_invalid
3358 b2_nullEdge = cvar.b2_nullEdge
3359
3361 """Proxy of C++ b2Proxy class"""
3362 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
3363 __repr__ = _swig_repr
3365 """GetNext(self) -> uint16"""
3366 return _Box2D.b2Proxy_GetNext(self)
3367
3369 """SetNext(self, uint16 next)"""
3370 return _Box2D.b2Proxy_SetNext(self, *args)
3371
3373 """IsValid(self) -> bool"""
3374 return _Box2D.b2Proxy_IsValid(self)
3375
3376 lowerBounds = _swig_property(_Box2D.b2Proxy_lowerBounds_get, _Box2D.b2Proxy_lowerBounds_set)
3377 upperBounds = _swig_property(_Box2D.b2Proxy_upperBounds_get, _Box2D.b2Proxy_upperBounds_set)
3378 overlapCount = _swig_property(_Box2D.b2Proxy_overlapCount_get, _Box2D.b2Proxy_overlapCount_set)
3379 timeStamp = _swig_property(_Box2D.b2Proxy_timeStamp_get, _Box2D.b2Proxy_timeStamp_set)
3381 return """b2Proxy(
3382 lowerBounds = %s,
3383 overlapCount = %s,
3384 timeStamp = %s,
3385 upperBounds = %s,
3386 userData = %s,
3387 IsValid() = %s)"""% tuple(str(a) for a in\
3388 (self.lowerBounds,self.overlapCount,self.timeStamp,self.upperBounds,self.userData,self.IsValid()))
3389
3390 __getstate__=_generic_getstate
3391 __setstate__=_generic_setstate
3392
3394 """__init__(self) -> b2Proxy"""
3395 _Box2D.b2Proxy_swiginit(self,_Box2D.new_b2Proxy())
3396 __swig_destroy__ = _Box2D.delete_b2Proxy
3397 b2Proxy.GetNext = new_instancemethod(_Box2D.b2Proxy_GetNext,None,b2Proxy)
3398 b2Proxy.SetNext = new_instancemethod(_Box2D.b2Proxy_SetNext,None,b2Proxy)
3399 b2Proxy.IsValid = new_instancemethod(_Box2D.b2Proxy_IsValid,None,b2Proxy)
3400 b2Proxy_swigregister = _Box2D.b2Proxy_swigregister
3401 b2Proxy_swigregister(b2Proxy)
3402
3404 """Proxy of C++ b2BroadPhase class"""
3405 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
3406 __repr__ = _swig_repr
3408 """__init__(self, b2AABB worldAABB, b2PairCallback callback) -> b2BroadPhase"""
3409 _Box2D.b2BroadPhase_swiginit(self,_Box2D.new_b2BroadPhase(*args))
3410 __swig_destroy__ = _Box2D.delete_b2BroadPhase
3412 """InRange(self, b2AABB aabb) -> bool"""
3413 return _Box2D.b2BroadPhase_InRange(self, *args)
3414
3416 """CreateProxy(self, b2AABB aabb, void $ignore) -> uint16"""
3417 return _Box2D.b2BroadPhase_CreateProxy(self, *args)
3418
3420 """DestroyProxy(self, int32 proxyId)"""
3421 return _Box2D.b2BroadPhase_DestroyProxy(self, *args)
3422
3424 """MoveProxy(self, int32 proxyId, b2AABB aabb)"""
3425 return _Box2D.b2BroadPhase_MoveProxy(self, *args)
3426
3428 """Commit(self)"""
3429 return _Box2D.b2BroadPhase_Commit(self)
3430
3432 """GetProxy(self, int32 proxyId) -> b2Proxy"""
3433 return _Box2D.b2BroadPhase_GetProxy(self, *args)
3434
3435 - def Query(self, *args):
3436 """Query(self, b2AABB aabb, void $ignore, int32 maxCount) -> int32"""
3437 return _Box2D.b2BroadPhase_Query(self, *args)
3438
3440 """QuerySegment(self, b2Segment segment, void $ignore, int32 maxCount, SortKeyFunc sortKey) -> int32"""
3441 return _Box2D.b2BroadPhase_QuerySegment(self, *args)
3442
3444 """Validate(self)"""
3445 return _Box2D.b2BroadPhase_Validate(self)
3446
3448 """ValidatePairs(self)"""
3449 return _Box2D.b2BroadPhase_ValidatePairs(self)
3450
3451 pairManager = _swig_property(_Box2D.b2BroadPhase_pairManager_get, _Box2D.b2BroadPhase_pairManager_set)
3452 proxyPool = _swig_property(_Box2D.b2BroadPhase_proxyPool_get, _Box2D.b2BroadPhase_proxyPool_set)
3453 freeProxy = _swig_property(_Box2D.b2BroadPhase_freeProxy_get, _Box2D.b2BroadPhase_freeProxy_set)
3454 bounds = _swig_property(_Box2D.b2BroadPhase_bounds_get, _Box2D.b2BroadPhase_bounds_set)
3455 queryResults = _swig_property(_Box2D.b2BroadPhase_queryResults_get, _Box2D.b2BroadPhase_queryResults_set)
3456 querySortKeys = _swig_property(_Box2D.b2BroadPhase_querySortKeys_get, _Box2D.b2BroadPhase_querySortKeys_set)
3457 queryResultCount = _swig_property(_Box2D.b2BroadPhase_queryResultCount_get, _Box2D.b2BroadPhase_queryResultCount_set)
3458 worldAABB = _swig_property(_Box2D.b2BroadPhase_worldAABB_get, _Box2D.b2BroadPhase_worldAABB_set)
3459 quantizationFactor = _swig_property(_Box2D.b2BroadPhase_quantizationFactor_get, _Box2D.b2BroadPhase_quantizationFactor_set)
3460 proxyCount = _swig_property(_Box2D.b2BroadPhase_proxyCount_get, _Box2D.b2BroadPhase_proxyCount_set)
3461 timeStamp = _swig_property(_Box2D.b2BroadPhase_timeStamp_get, _Box2D.b2BroadPhase_timeStamp_set)
3462 s_validate = _swig_property(_Box2D.b2BroadPhase_s_validate_get, _Box2D.b2BroadPhase_s_validate_set)
3464 return """b2BroadPhase(
3465 bounds = %s,
3466 freeProxy = %s,
3467 pairManager = %s,
3468 proxyCount = %s,
3469 proxyPool = %s,
3470 quantizationFactor = %s,
3471 queryResultCount = %s,
3472 queryResults = %s,
3473 querySortKeys = %s,
3474 s_validate = %s,
3475 timeStamp = %s,
3476 worldAABB = %s)"""% tuple(str(a) for a in\
3477 (self.bounds,self.freeProxy,self.pairManager,self.proxyCount,self.proxyPool,self.quantizationFactor,self.queryResultCount,self.queryResults,self.querySortKeys,self.s_validate,self.timeStamp,self.worldAABB))
3478
3479 __getstate__=_generic_getstate
3480 __setstate__=_generic_setstate
3481
3482 b2BroadPhase.InRange = new_instancemethod(_Box2D.b2BroadPhase_InRange,None,b2BroadPhase)
3483 b2BroadPhase.CreateProxy = new_instancemethod(_Box2D.b2BroadPhase_CreateProxy,None,b2BroadPhase)
3484 b2BroadPhase.DestroyProxy = new_instancemethod(_Box2D.b2BroadPhase_DestroyProxy,None,b2BroadPhase)
3485 b2BroadPhase.MoveProxy = new_instancemethod(_Box2D.b2BroadPhase_MoveProxy,None,b2BroadPhase)
3486 b2BroadPhase.Commit = new_instancemethod(_Box2D.b2BroadPhase_Commit,None,b2BroadPhase)
3487 b2BroadPhase.GetProxy = new_instancemethod(_Box2D.b2BroadPhase_GetProxy,None,b2BroadPhase)
3488 b2BroadPhase.Query = new_instancemethod(_Box2D.b2BroadPhase_Query,None,b2BroadPhase)
3489 b2BroadPhase.QuerySegment = new_instancemethod(_Box2D.b2BroadPhase_QuerySegment,None,b2BroadPhase)
3490 b2BroadPhase.Validate = new_instancemethod(_Box2D.b2BroadPhase_Validate,None,b2BroadPhase)
3491 b2BroadPhase.ValidatePairs = new_instancemethod(_Box2D.b2BroadPhase_ValidatePairs,None,b2BroadPhase)
3492 b2BroadPhase_swigregister = _Box2D.b2BroadPhase_swigregister
3493 b2BroadPhase_swigregister(b2BroadPhase)
3494
3496 """Joints and shapes are destroyed when their associated body is destroyed. Implement this listener so that you may nullify references to these joints and shapes."""
3497 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
3498 __repr__ = _swig_repr
3499 __swig_destroy__ = _Box2D.delete_b2DestructionListener
3501 """
3502 SayGoodbye(self, b2Joint joint)
3503 SayGoodbye(self, b2Shape shape)
3504
3505 Called when any shape is about to be destroyed due to the destruction of its parent body.
3506 """
3507 return _Box2D.b2DestructionListener_SayGoodbye(self, *args)
3508
3510 return "b2DestructionListener()"
3511
3512 __getstate__=_generic_getstate
3513 __setstate__=_generic_setstate
3514
3516 """__init__(self) -> b2DestructionListener"""
3517 if self.__class__ == b2DestructionListener:
3518 _self = None
3519 else:
3520 _self = self
3521 _Box2D.b2DestructionListener_swiginit(self,_Box2D.new_b2DestructionListener(_self, ))
3523 self.this.disown()
3524 _Box2D.disown_b2DestructionListener(self)
3525 return weakref_proxy(self)
3526 b2DestructionListener.SayGoodbye = new_instancemethod(_Box2D.b2DestructionListener_SayGoodbye,None,b2DestructionListener)
3527 b2DestructionListener_swigregister = _Box2D.b2DestructionListener_swigregister
3528 b2DestructionListener_swigregister(b2DestructionListener)
3529
3531 """This is called when a body's shape passes outside of the world boundary."""
3532 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
3533 __repr__ = _swig_repr
3534 __swig_destroy__ = _Box2D.delete_b2BoundaryListener
3536 """
3537 Violation(self, b2Body body)
3538
3539 This is called for each body that leaves the world boundary.
3540 WARNING:
3541 you can't modify the world inside this callback.
3542 """
3543 return _Box2D.b2BoundaryListener_Violation(self, *args)
3544
3546 return "b2BoundaryListener()"
3547
3548 __getstate__=_generic_getstate
3549 __setstate__=_generic_setstate
3550
3552 """__init__(self) -> b2BoundaryListener"""
3553 if self.__class__ == b2BoundaryListener:
3554 _self = None
3555 else:
3556 _self = self
3557 _Box2D.b2BoundaryListener_swiginit(self,_Box2D.new_b2BoundaryListener(_self, ))
3559 self.this.disown()
3560 _Box2D.disown_b2BoundaryListener(self)
3561 return weakref_proxy(self)
3562 b2BoundaryListener.Violation = new_instancemethod(_Box2D.b2BoundaryListener_Violation,None,b2BoundaryListener)
3563 b2BoundaryListener_swigregister = _Box2D.b2BoundaryListener_swigregister
3564 b2BoundaryListener_swigregister(b2BoundaryListener)
3565
3606 b2ContactFilter.ShouldCollide = new_instancemethod(_Box2D.b2ContactFilter_ShouldCollide,None,b2ContactFilter)
3607 b2ContactFilter.RayCollide = new_instancemethod(_Box2D.b2ContactFilter_RayCollide,None,b2ContactFilter)
3608 b2ContactFilter_swigregister = _Box2D.b2ContactFilter_swigregister
3609 b2ContactFilter_swigregister(b2ContactFilter)
3610
3671 b2ContactListener.Add = new_instancemethod(_Box2D.b2ContactListener_Add,None,b2ContactListener)
3672 b2ContactListener.Persist = new_instancemethod(_Box2D.b2ContactListener_Persist,None,b2ContactListener)
3673 b2ContactListener.Remove = new_instancemethod(_Box2D.b2ContactListener_Remove,None,b2ContactListener)
3674 b2ContactListener.Result = new_instancemethod(_Box2D.b2ContactListener_Result,None,b2ContactListener)
3675 b2ContactListener_swigregister = _Box2D.b2ContactListener_swigregister
3676 b2ContactListener_swigregister(b2ContactListener)
3677
3679 """Color for debug drawing. Each value has the range [0,1]."""
3680 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
3681 __repr__ = _swig_repr
3683 """
3684 __init__(self) -> b2Color
3685 __init__(self, float32 r, float32 g, float32 b) -> b2Color
3686
3687 Color for debug drawing. Each value has the range [0,1].
3688 """
3689 _Box2D.b2Color_swiginit(self,_Box2D.new_b2Color(*args))
3690 r = _swig_property(_Box2D.b2Color_r_get, _Box2D.b2Color_r_set)
3691 g = _swig_property(_Box2D.b2Color_g_get, _Box2D.b2Color_g_set)
3692 b = _swig_property(_Box2D.b2Color_b_get, _Box2D.b2Color_b_set)
3694 return """b2Color(
3695 b = %s,
3696 g = %s,
3697 r = %s)"""% tuple(str(a) for a in\
3698 (self.b,self.g,self.r))
3699
3700 __getstate__=_generic_getstate
3701 __setstate__=_generic_setstate
3702
3703 __swig_destroy__ = _Box2D.delete_b2Color
3704 b2Color_swigregister = _Box2D.b2Color_swigregister
3705 b2Color_swigregister(b2Color)
3706
3708 """Implement and register this class with a b2Worldto provide debug drawing of physics entities in your game."""
3709 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
3710 __repr__ = _swig_repr
3712 """
3713 __init__(self) -> b2DebugDraw
3714
3715 Implement and register this class with a b2Worldto provide debug drawing of physics entities in your game.
3716 """
3717 if self.__class__ == b2DebugDraw:
3718 _self = None
3719 else:
3720 _self = self
3721 _Box2D.b2DebugDraw_swiginit(self,_Box2D.new_b2DebugDraw(_self, ))
3722 __swig_destroy__ = _Box2D.delete_b2DebugDraw
3723 e_shapeBit = _Box2D.b2DebugDraw_e_shapeBit
3724 e_jointBit = _Box2D.b2DebugDraw_e_jointBit
3725 e_coreShapeBit = _Box2D.b2DebugDraw_e_coreShapeBit
3726 e_aabbBit = _Box2D.b2DebugDraw_e_aabbBit
3727 e_obbBit = _Box2D.b2DebugDraw_e_obbBit
3728 e_pairBit = _Box2D.b2DebugDraw_e_pairBit
3729 e_centerOfMassBit = _Box2D.b2DebugDraw_e_centerOfMassBit
3730 e_controllerBit = _Box2D.b2DebugDraw_e_controllerBit
3732 """
3733 SetFlags(self, uint32 flags)
3734
3735 Set the drawing flags.
3736 """
3737 return _Box2D.b2DebugDraw_SetFlags(self, *args)
3738
3740 """
3741 GetFlags(self) -> uint32
3742
3743 Get the drawing flags.
3744 """
3745 return _Box2D.b2DebugDraw_GetFlags(self)
3746
3748 """
3749 AppendFlags(self, uint32 flags)
3750
3751 Append flags to the current flags.
3752 """
3753 return _Box2D.b2DebugDraw_AppendFlags(self, *args)
3754
3756 """
3757 ClearFlags(self, uint32 flags)
3758
3759 Clear flags from the current flags.
3760 """
3761 return _Box2D.b2DebugDraw_ClearFlags(self, *args)
3762
3764 """
3765 DrawPolygon(self, b2Vec2 vertices, int32 vertexCount, b2Color color)
3766
3767 Draw a closed polygon provided in CCW order.
3768 """
3769 return _Box2D.b2DebugDraw_DrawPolygon(self, *args)
3770
3772 """
3773 DrawSolidPolygon(self, b2Vec2 vertices, int32 vertexCount, b2Color color)
3774
3775 Draw a solid closed polygon provided in CCW order.
3776 """
3777 return _Box2D.b2DebugDraw_DrawSolidPolygon(self, *args)
3778
3780 """
3781 DrawCircle(self, b2Vec2 center, float32 radius, b2Color color)
3782
3783 Draw a circle.
3784 """
3785 return _Box2D.b2DebugDraw_DrawCircle(self, *args)
3786
3788 """
3789 DrawSolidCircle(self, b2Vec2 center, float32 radius, b2Vec2 axis, b2Color color)
3790
3791 Draw a solid circle.
3792 """
3793 return _Box2D.b2DebugDraw_DrawSolidCircle(self, *args)
3794
3796 """
3797 DrawSegment(self, b2Vec2 p1, b2Vec2 p2, b2Color color)
3798
3799 Draw a line segment.
3800 """
3801 return _Box2D.b2DebugDraw_DrawSegment(self, *args)
3802
3815
3817 return """b2DebugDraw(
3818 GetFlags() = %s,
3819 e_aabbBit = %s,
3820 e_centerOfMassBit = %s,
3821 e_controllerBit = %s,
3822 e_coreShapeBit = %s,
3823 e_jointBit = %s,
3824 e_obbBit = %s,
3825 e_pairBit = %s,
3826 e_shapeBit = %s)"""% tuple(str(a) for a in\
3827 (self.GetFlags(),self.e_aabbBit,self.e_centerOfMassBit,self.e_controllerBit,self.e_coreShapeBit,self.e_jointBit,self.e_obbBit,self.e_pairBit,self.e_shapeBit))
3828
3829 __getstate__=_generic_getstate
3830 __setstate__=_generic_setstate
3831
3833 self.this.disown()
3834 _Box2D.disown_b2DebugDraw(self)
3835 return weakref_proxy(self)
3836 b2DebugDraw.SetFlags = new_instancemethod(_Box2D.b2DebugDraw_SetFlags,None,b2DebugDraw)
3837 b2DebugDraw.GetFlags = new_instancemethod(_Box2D.b2DebugDraw_GetFlags,None,b2DebugDraw)
3838 b2DebugDraw.AppendFlags = new_instancemethod(_Box2D.b2DebugDraw_AppendFlags,None,b2DebugDraw)
3839 b2DebugDraw.ClearFlags = new_instancemethod(_Box2D.b2DebugDraw_ClearFlags,None,b2DebugDraw)
3840 b2DebugDraw.DrawPolygon = new_instancemethod(_Box2D.b2DebugDraw_DrawPolygon,None,b2DebugDraw)
3841 b2DebugDraw.DrawSolidPolygon = new_instancemethod(_Box2D.b2DebugDraw_DrawSolidPolygon,None,b2DebugDraw)
3842 b2DebugDraw.DrawCircle = new_instancemethod(_Box2D.b2DebugDraw_DrawCircle,None,b2DebugDraw)
3843 b2DebugDraw.DrawSolidCircle = new_instancemethod(_Box2D.b2DebugDraw_DrawSolidCircle,None,b2DebugDraw)
3844 b2DebugDraw.DrawSegment = new_instancemethod(_Box2D.b2DebugDraw_DrawSegment,None,b2DebugDraw)
3845 b2DebugDraw.DrawXForm = new_instancemethod(_Box2D.b2DebugDraw_DrawXForm,None,b2DebugDraw)
3846 b2DebugDraw_swigregister = _Box2D.b2DebugDraw_swigregister
3847 b2DebugDraw_swigregister(b2DebugDraw)
3848
3850 """Proxy of C++ b2BlockAllocator class"""
3851 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
3852 __repr__ = _swig_repr
3854 """__init__(self) -> b2BlockAllocator"""
3855 _Box2D.b2BlockAllocator_swiginit(self,_Box2D.new_b2BlockAllocator())
3856 __swig_destroy__ = _Box2D.delete_b2BlockAllocator
3858 """Allocate(self, int32 size) -> void"""
3859 return _Box2D.b2BlockAllocator_Allocate(self, *args)
3860
3861 - def Free(self, *args):
3862 """Free(self, void p, int32 size)"""
3863 return _Box2D.b2BlockAllocator_Free(self, *args)
3864
3866 """Clear(self)"""
3867 return _Box2D.b2BlockAllocator_Clear(self)
3868
3870 return "b2BlockAllocator()"
3871
3872 __getstate__=_generic_getstate
3873 __setstate__=_generic_setstate
3874
3875 b2BlockAllocator.Allocate = new_instancemethod(_Box2D.b2BlockAllocator_Allocate,None,b2BlockAllocator)
3876 b2BlockAllocator.Free = new_instancemethod(_Box2D.b2BlockAllocator_Free,None,b2BlockAllocator)
3877 b2BlockAllocator.Clear = new_instancemethod(_Box2D.b2BlockAllocator_Clear,None,b2BlockAllocator)
3878 b2BlockAllocator_swigregister = _Box2D.b2BlockAllocator_swigregister
3879 b2BlockAllocator_swigregister(b2BlockAllocator)
3880 b2_chunkSize = cvar.b2_chunkSize
3881 b2_maxBlockSize = cvar.b2_maxBlockSize
3882 b2_blockSizes = cvar.b2_blockSizes
3883 b2_chunkArrayIncrement = cvar.b2_chunkArrayIncrement
3884
3885 -class b2StackEntry(object):
3886 """Proxy of C++ b2StackEntry class"""
3887 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
3888 __repr__ = _swig_repr
3889 data = _swig_property(_Box2D.b2StackEntry_data_get, _Box2D.b2StackEntry_data_set)
3890 size = _swig_property(_Box2D.b2StackEntry_size_get, _Box2D.b2StackEntry_size_set)
3891 usedMalloc = _swig_property(_Box2D.b2StackEntry_usedMalloc_get, _Box2D.b2StackEntry_usedMalloc_set)
3892 - def __repr__(self):
3893 return """b2StackEntry(
3894 data = %s,
3895 size = %s,
3896 usedMalloc = %s)"""% tuple(str(a) for a in\
3897 (self.data,self.size,self.usedMalloc))
3898
3899 __getstate__=_generic_getstate
3900 __setstate__=_generic_setstate
3901
3902 - def __init__(self):
3903 """__init__(self) -> b2StackEntry"""
3904 _Box2D.b2StackEntry_swiginit(self,_Box2D.new_b2StackEntry())
3905 __swig_destroy__ = _Box2D.delete_b2StackEntry
3906 b2StackEntry_swigregister = _Box2D.b2StackEntry_swigregister
3907 b2StackEntry_swigregister(b2StackEntry)
3908 b2_stackSize = cvar.b2_stackSize
3909 b2_maxStackEntries = cvar.b2_maxStackEntries
3910
3912 """Proxy of C++ b2StackAllocator class"""
3913 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
3914 __repr__ = _swig_repr
3916 """__init__(self) -> b2StackAllocator"""
3917 _Box2D.b2StackAllocator_swiginit(self,_Box2D.new_b2StackAllocator())
3918 __swig_destroy__ = _Box2D.delete_b2StackAllocator
3920 """Allocate(self, int32 size) -> void"""
3921 return _Box2D.b2StackAllocator_Allocate(self, *args)
3922
3923 - def Free(self, *args):
3924 """Free(self, void p)"""
3925 return _Box2D.b2StackAllocator_Free(self, *args)
3926
3928 """GetMaxAllocation(self) -> int32"""
3929 return _Box2D.b2StackAllocator_GetMaxAllocation(self)
3930
3932 return """b2StackAllocator(
3933 GetMaxAllocation() = %s)"""% tuple(str(a) for a in\
3934 (self.GetMaxAllocation()))
3935
3936 __getstate__=_generic_getstate
3937 __setstate__=_generic_setstate
3938
3939 b2StackAllocator.Allocate = new_instancemethod(_Box2D.b2StackAllocator_Allocate,None,b2StackAllocator)
3940 b2StackAllocator.Free = new_instancemethod(_Box2D.b2StackAllocator_Free,None,b2StackAllocator)
3941 b2StackAllocator.GetMaxAllocation = new_instancemethod(_Box2D.b2StackAllocator_GetMaxAllocation,None,b2StackAllocator)
3942 b2StackAllocator_swigregister = _Box2D.b2StackAllocator_swigregister
3943 b2StackAllocator_swigregister(b2StackAllocator)
3944
3965 __swig_destroy__ = _Box2D.delete_b2ContactRegister
3966 b2ContactRegister_swigregister = _Box2D.b2ContactRegister_swigregister
3967 b2ContactRegister_swigregister(b2ContactRegister)
3968
3989 __swig_destroy__ = _Box2D.delete_b2ContactEdge
3990 b2ContactEdge_swigregister = _Box2D.b2ContactEdge_swigregister
3991 b2ContactEdge_swigregister(b2ContactEdge)
3992
4025 __swig_destroy__ = _Box2D.delete_b2ContactPoint
4026 b2ContactPoint_swigregister = _Box2D.b2ContactPoint_swigregister
4027 b2ContactPoint_swigregister(b2ContactPoint)
4028
4057 __swig_destroy__ = _Box2D.delete_b2ContactResult
4058 b2ContactResult_swigregister = _Box2D.b2ContactResult_swigregister
4059 b2ContactResult_swigregister(b2ContactResult)
4060
4183
4184 b2Contact.GetManifolds = new_instancemethod(_Box2D.b2Contact_GetManifolds,None,b2Contact)
4185 b2Contact.GetManifoldCount = new_instancemethod(_Box2D.b2Contact_GetManifoldCount,None,b2Contact)
4186 b2Contact.IsSolid = new_instancemethod(_Box2D.b2Contact_IsSolid,None,b2Contact)
4187 b2Contact.GetNext = new_instancemethod(_Box2D.b2Contact_GetNext,None,b2Contact)
4188 b2Contact.GetShape1 = new_instancemethod(_Box2D.b2Contact_GetShape1,None,b2Contact)
4189 b2Contact.GetShape2 = new_instancemethod(_Box2D.b2Contact_GetShape2,None,b2Contact)
4190 b2Contact.Update = new_instancemethod(_Box2D.b2Contact_Update,None,b2Contact)
4191 b2Contact.Evaluate = new_instancemethod(_Box2D.b2Contact_Evaluate,None,b2Contact)
4192 b2Contact_swigregister = _Box2D.b2Contact_swigregister
4193 b2Contact_swigregister(b2Contact)
4194
4201
4205
4209
4213
4239
4240 __getstate__=_generic_getstate
4241 __setstate__=_generic_setstate
4242
4243 __swig_destroy__ = _Box2D.delete_b2NullContact
4244 b2NullContact_swigregister = _Box2D.b2NullContact_swigregister
4245 b2NullContact_swigregister(b2NullContact)
4246
4257
4261
4262 world = _swig_property(_Box2D.b2ContactManager_world_get, _Box2D.b2ContactManager_world_set)
4263 nullContact = _swig_property(_Box2D.b2ContactManager_nullContact_get, _Box2D.b2ContactManager_nullContact_set)
4264 destroyImmediate = _swig_property(_Box2D.b2ContactManager_destroyImmediate_get, _Box2D.b2ContactManager_destroyImmediate_set)
4271
4272 __getstate__=_generic_getstate
4273 __setstate__=_generic_setstate
4274
4275 __swig_destroy__ = _Box2D.delete_b2ContactManager
4276 b2ContactManager.Destroy = new_instancemethod(_Box2D.b2ContactManager_Destroy,None,b2ContactManager)
4277 b2ContactManager.Collide = new_instancemethod(_Box2D.b2ContactManager_Collide,None,b2ContactManager)
4278 b2ContactManager_swigregister = _Box2D.b2ContactManager_swigregister
4279 b2ContactManager_swigregister(b2ContactManager)
4280
4282 """Proxy of C++ b2TimeStep class"""
4283 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
4284 __repr__ = _swig_repr
4285 dt = _swig_property(_Box2D.b2TimeStep_dt_get, _Box2D.b2TimeStep_dt_set)
4286 inv_dt = _swig_property(_Box2D.b2TimeStep_inv_dt_get, _Box2D.b2TimeStep_inv_dt_set)
4287 dtRatio = _swig_property(_Box2D.b2TimeStep_dtRatio_get, _Box2D.b2TimeStep_dtRatio_set)
4288 velocityIterations = _swig_property(_Box2D.b2TimeStep_velocityIterations_get, _Box2D.b2TimeStep_velocityIterations_set)
4289 positionIterations = _swig_property(_Box2D.b2TimeStep_positionIterations_get, _Box2D.b2TimeStep_positionIterations_set)
4290 warmStarting = _swig_property(_Box2D.b2TimeStep_warmStarting_get, _Box2D.b2TimeStep_warmStarting_set)
4292 return """b2TimeStep(
4293 dt = %s,
4294 dtRatio = %s,
4295 inv_dt = %s,
4296 positionIterations = %s,
4297 velocityIterations = %s,
4298 warmStarting = %s)"""% tuple(str(a) for a in\
4299 (self.dt,self.dtRatio,self.inv_dt,self.positionIterations,self.velocityIterations,self.warmStarting))
4300
4301 __getstate__=_generic_getstate
4302 __setstate__=_generic_setstate
4303
4305 """__init__(self) -> b2TimeStep"""
4306 _Box2D.b2TimeStep_swiginit(self,_Box2D.new_b2TimeStep())
4307 __swig_destroy__ = _Box2D.delete_b2TimeStep
4308 b2TimeStep_swigregister = _Box2D.b2TimeStep_swigregister
4309 b2TimeStep_swigregister(b2TimeStep)
4310
4312 """The world class manages all physics entities, dynamic simulation, and asynchronous queries. The world also contains efficient memory management facilities."""
4313 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
4314 __repr__ = _swig_repr
4316 """
4317 __init__(self, b2AABB worldAABB, b2Vec2 gravity, bool doSleep) -> b2World
4318
4319 Construct a world object.
4320
4321 Parameters:
4322 -----------
4323
4324 worldAABB: a bounding box that completely encompasses all your shapes.
4325
4326 gravity: the world gravity vector.
4327
4328 doSleep: improve performance by not simulating inactive bodies.
4329 """
4330 _Box2D.b2World_swiginit(self,_Box2D.new_b2World(*args))
4331 __swig_destroy__ = _Box2D.delete_b2World
4333 """
4334 SetDestructionListener(self, b2DestructionListener listener)
4335
4336 Register a destruction listener.
4337 """
4338 return _Box2D.b2World_SetDestructionListener(self, *args)
4339
4341 """
4342 SetBoundaryListener(self, b2BoundaryListener listener)
4343
4344 Register a broad-phase boundary listener.
4345 """
4346 return _Box2D.b2World_SetBoundaryListener(self, *args)
4347
4355
4363
4365 """
4366 SetDebugDraw(self, b2DebugDraw debugDraw)
4367
4368 Register a routine for debug drawing. The debug draw functions are called inside the b2World::Stepmethod, so make sure your renderer is ready to consume draw commands when you call Step().
4369 """
4370 return _Box2D.b2World_SetDebugDraw(self, *args)
4371
4373 """
4374 CreateController(self, b2ControllerDef _def) -> b2Controller
4375
4376 Add a controller to the world.
4377 """
4378 return _Box2D.b2World_CreateController(self, *args)
4379
4381 """
4382 DestroyController(self, b2Controller controller)
4383
4384 Removes a controller from the world.
4385 """
4386 return _Box2D.b2World_DestroyController(self, *args)
4387
4388 - def GetGroundBody(self):
4389 """
4390 GetGroundBody(self) -> b2Body
4391
4392 The world provides a single static ground body with no collision shapes. You can use this to simplify the creation of joints and static shapes.
4393 """
4394 return _Box2D.b2World_GetGroundBody(self)
4395
4396 - def Step(self, *args):
4397 """
4398 Step(self, float32 timeStep, int32 velocityIterations, int32 positionIterations)
4399
4400 Take a time step. This performs collision detection, integration, and constraint solution.
4401
4402 Parameters:
4403 -----------
4404
4405 timeStep: the amount of time to simulate, this should not vary.
4406
4407 velocityIterations: for the velocity constraint solver.
4408
4409 positionIterations: for the position constraint solver.
4410 """
4411 return _Box2D.b2World_Step(self, *args)
4412
4414 """
4415 InRange(self, b2AABB aabb) -> bool
4416
4417 Check if the AABB is within the broadphase limits.
4418 """
4419 return _Box2D.b2World_InRange(self, *args)
4420
4421 - def _GetBodyList(self):
4422 """
4423 _GetBodyList(self) -> b2Body
4424
4425 Get the world body list. With the returned body, use b2Body::GetNextto get the next body in the world list. A NULL body indicates the end of the list.
4426 the head of the world body list.
4427 """
4428 return _Box2D.b2World__GetBodyList(self)
4429
4431 """
4432 _GetJointList(self) -> b2Joint
4433
4434 Get the world joint list. With the returned joint, use b2Joint::GetNextto get the next joint in the world list. A NULL joint indicates the end of the list.
4435 the head of the world joint list.
4436 """
4437 return _Box2D.b2World__GetJointList(self)
4438
4440 """
4441 _GetControllerList(self) -> b2Controller
4442
4443 Get the world controller list. With the returned controller, use b2Controller::GetNextto get the next controller in the world list. A NULL controller indicates the end of the list.
4444 the head of the world controller list.
4445 """
4446 return _Box2D.b2World__GetControllerList(self)
4447
4449 """
4450 Refilter(self, b2Shape shape)
4451
4452 Re-filter a shape. This re-runs contact filtering on a shape.
4453 """
4454 return _Box2D.b2World_Refilter(self, *args)
4455
4457 """
4458 SetWarmStarting(self, bool flag)
4459
4460 Enable/disable warm starting. For testing.
4461 """
4462 return _Box2D.b2World_SetWarmStarting(self, *args)
4463
4465 """
4466 SetContinuousPhysics(self, bool flag)
4467
4468 Enable/disable continuous physics. For testing.
4469 """
4470 return _Box2D.b2World_SetContinuousPhysics(self, *args)
4471
4473 """
4474 Validate(self)
4475
4476 Perform validation of internal data structures.
4477 """
4478 return _Box2D.b2World_Validate(self)
4479
4481 """
4482 GetProxyCount(self) -> int32
4483
4484 Get the number of broad-phase proxies.
4485 """
4486 return _Box2D.b2World_GetProxyCount(self)
4487
4489 """
4490 GetPairCount(self) -> int32
4491
4492 Get the number of broad-phase pairs.
4493 """
4494 return _Box2D.b2World_GetPairCount(self)
4495
4496 - def GetBodyCount(self):
4497 """
4498 GetBodyCount(self) -> int32
4499
4500 Get the number of bodies.
4501 """
4502 return _Box2D.b2World_GetBodyCount(self)
4503
4505 """
4506 GetJointCount(self) -> int32
4507
4508 Get the number of joints.
4509 """
4510 return _Box2D.b2World_GetJointCount(self)
4511
4519
4521 """
4522 GetControllerCount(self) -> int32
4523
4524 Get the number of controllers.
4525 """
4526 return _Box2D.b2World_GetControllerCount(self)
4527
4529 """
4530 SetGravity(self, b2Vec2 gravity)
4531
4532 Change the global gravity vector.
4533 """
4534 return _Box2D.b2World_SetGravity(self, *args)
4535
4537 """
4538 GetGravity(self) -> b2Vec2
4539
4540 Get the global gravity vector.
4541 """
4542 return _Box2D.b2World_GetGravity(self)
4543
4545 """
4546 GetWorldAABB(self) -> b2AABB
4547
4548 Get the world's AABB.
4549 """
4550 return _Box2D.b2World_GetWorldAABB(self)
4551
4553 """
4554 CanSleep(self) -> bool
4555
4556 Whether or not bodies can sleep.
4557 """
4558 return _Box2D.b2World_CanSleep(self)
4559
4561 return """b2World(
4562 doSleep = %s,
4563 gravity = %s,
4564 groundBody = %s,
4565 worldAABB = %s,
4566 GetBodyCount() = %s,
4567 GetContactCount() = %s,
4568 GetControllerCount() = %s,
4569 GetJointCount() = %s,
4570 GetPairCount() = %s,
4571 GetProxyCount() = %s)"""% tuple(str(a) for a in\
4572 (self.doSleep,self.gravity,self.groundBody,self.worldAABB,self.GetBodyCount(),self.GetContactCount(),self.GetControllerCount(),self.GetJointCount(),self.GetPairCount(),self.GetProxyCount()))
4573
4574 __getstate__=_pickle_get_b2world
4575 __setstate__=_pickle_factory_set
4576 _pickle_finalize=_pickle_finalize_world
4577
4578 - def CreateBody(self, *args):
4579 """
4580 CreateBody(self, b2BodyDef defn) -> b2Body
4581
4582 Create a rigid body given a definition. No reference to the definition is retained.
4583 WARNING:
4584 This function is locked during callbacks.
4585 """
4586 return _Box2D.b2World_CreateBody(self, *args)
4587
4589 """
4590 CreateJoint(self, b2JointDef defn) -> b2Joint
4591
4592 Create a joint to constrain bodies together. No reference to the definition is retained. This may cause the connected bodies to cease colliding.
4593 WARNING:
4594 This function is locked during callbacks.
4595 """
4596 return _Box2D.b2World_CreateJoint(self, *args)
4597
4598 - def DestroyBody(self, *args):
4599 """
4600 DestroyBody(self, b2Body body)
4601
4602 Destroy a rigid body given a definition. No reference to the definition is retained. This function is locked during callbacks.
4603 WARNING:
4604 This automatically deletes all associated shapes and joints.
4605
4606 This function is locked during callbacks.
4607 """
4608 return _Box2D.b2World_DestroyBody(self, *args)
4609
4611 """
4612 DestroyJoint(self, b2Joint joint)
4613
4614 Destroy a joint. This may cause the connected bodies to begin colliding.
4615 WARNING:
4616 This function is locked during callbacks.
4617 """
4618 return _Box2D.b2World_DestroyJoint(self, *args)
4619
4621 """
4622 Raycast(self, b2Segment segment, b2Shape shapes, int32 maxCount,
4623 bool solidShapes, void $ignore) -> int32
4624 Raycast(self, b2Segment segment, int32 maxCount, bool solidShapes,
4625 PyObject $ignore) -> PyObject
4626
4627 Query the world for all shapes that intersect a given segment. You provide a shape pointer buffer of specified size. The number of shapes found is returned, and the buffer is filled in order of intersection
4628
4629 Parameters:
4630 -----------
4631
4632 segment:
4633 defines the begin and end point of the ray cast, from p1 to p2. Use b2Segment.Extend to create (semi-)infinite rays
4634
4635 shapes:
4636 a user allocated shape pointer array of size maxCount (or greater).
4637
4638 maxCount:
4639 the capacity of the shapes array
4640
4641 solidShapes:
4642 determines if shapes that the ray starts in are counted as hits.
4643
4644 userData:
4645 passed through the worlds contact filter, with method RayCollide. This can be used to filter valid shapes
4646
4647 the number of shapes found
4648 """
4649 return _Box2D.b2World_Raycast(self, *args)
4650
4652 """
4653 RaycastOne(self, b2Segment segment, float32 _lambda, b2Vec2 normal,
4654 bool solidShapes, void $ignore) -> b2Shape
4655 RaycastOne(self, b2Segment segment, bool solidShapes, PyObject $ignore) -> PyObject
4656
4657 Performs a raycast as with Raycast, finding the first intersecting shape.
4658
4659 Parameters:
4660 -----------
4661
4662 segment:
4663 defines the begin and end point of the ray cast, from p1 to p2. Use b2Segment.Extend to create (semi-)infinite rays
4664
4665 lambda:
4666 returns the hit fraction. You can use this to compute the contact point p = (1 - lambda) * segment.p1 + lambda * segment.p2.
4667
4668 normal:
4669 returns the normal at the contact point. If there is no intersection, the normal is not set.
4670
4671 solidShapes:
4672 determines if shapes that the ray starts in are counted as hits.
4673
4674 the colliding shape shape, or null if not found
4675 """
4676 return _Box2D.b2World_RaycastOne(self, *args)
4677
4678 - def Query(self, *args):
4679 """
4680 Query(self, b2AABB aabb, b2Shape shapes, int32 maxCount) -> int32
4681 Query(self, b2AABB aabb, uint32 maxCount) -> PyObject
4682
4683 Query the world for all shapes that potentially overlap the provided AABB. You provide a shape pointer buffer of specified size. The number of shapes found is returned.
4684
4685 Parameters:
4686 -----------
4687
4688 aabb: the query box.
4689
4690 shapes: a user allocated shape pointer array of size maxCount (or greater).
4691
4692 maxCount: the capacity of the shapes array.
4693
4694 the number of shapes found in aabb.
4695 """
4696 return _Box2D.b2World_Query(self, *args)
4697
4709 - def GetBodyList(self):
4710 """
4711 Get a list of the bodies in this world
4712 """
4713 bodyList = []
4714 body = self._GetBodyList()
4715 while body:
4716 bodyList.append(body)
4717 body = body.GetNext()
4718 bodyList.reverse()
4719 return bodyList
4731
4733 """
4734 Iterates over the bodies in the world
4735 """
4736 for body in self.bodyList:
4737 yield body
4738
4739 gravity = property(GetGravity , SetGravity)
4740 jointList = property(GetJointList , None)
4741 bodyList = property(GetBodyList , None)
4742 groundBody= property(GetGroundBody, None)
4743 worldAABB = property(GetWorldAABB , None)
4744 doSleep = property(CanSleep , None)
4745 controllerList = property(GetControllerList, None)
4746
4747 b2World.SetDestructionListener = new_instancemethod(_Box2D.b2World_SetDestructionListener,None,b2World)
4748 b2World.SetBoundaryListener = new_instancemethod(_Box2D.b2World_SetBoundaryListener,None,b2World)
4749 b2World.SetContactFilter = new_instancemethod(_Box2D.b2World_SetContactFilter,None,b2World)
4750 b2World.SetContactListener = new_instancemethod(_Box2D.b2World_SetContactListener,None,b2World)
4751 b2World.SetDebugDraw = new_instancemethod(_Box2D.b2World_SetDebugDraw,None,b2World)
4752 b2World.CreateController = new_instancemethod(_Box2D.b2World_CreateController,None,b2World)
4753 b2World.DestroyController = new_instancemethod(_Box2D.b2World_DestroyController,None,b2World)
4754 b2World.GetGroundBody = new_instancemethod(_Box2D.b2World_GetGroundBody,None,b2World)
4755 b2World.Step = new_instancemethod(_Box2D.b2World_Step,None,b2World)
4756 b2World.InRange = new_instancemethod(_Box2D.b2World_InRange,None,b2World)
4757 b2World._GetBodyList = new_instancemethod(_Box2D.b2World__GetBodyList,None,b2World)
4758 b2World._GetJointList = new_instancemethod(_Box2D.b2World__GetJointList,None,b2World)
4759 b2World._GetControllerList = new_instancemethod(_Box2D.b2World__GetControllerList,None,b2World)
4760 b2World.Refilter = new_instancemethod(_Box2D.b2World_Refilter,None,b2World)
4761 b2World.SetWarmStarting = new_instancemethod(_Box2D.b2World_SetWarmStarting,None,b2World)
4762 b2World.SetContinuousPhysics = new_instancemethod(_Box2D.b2World_SetContinuousPhysics,None,b2World)
4763 b2World.Validate = new_instancemethod(_Box2D.b2World_Validate,None,b2World)
4764 b2World.GetProxyCount = new_instancemethod(_Box2D.b2World_GetProxyCount,None,b2World)
4765 b2World.GetPairCount = new_instancemethod(_Box2D.b2World_GetPairCount,None,b2World)
4766 b2World.GetBodyCount = new_instancemethod(_Box2D.b2World_GetBodyCount,None,b2World)
4767 b2World.GetJointCount = new_instancemethod(_Box2D.b2World_GetJointCount,None,b2World)
4768 b2World.GetContactCount = new_instancemethod(_Box2D.b2World_GetContactCount,None,b2World)
4769 b2World.GetControllerCount = new_instancemethod(_Box2D.b2World_GetControllerCount,None,b2World)
4770 b2World.SetGravity = new_instancemethod(_Box2D.b2World_SetGravity,None,b2World)
4771 b2World.GetGravity = new_instancemethod(_Box2D.b2World_GetGravity,None,b2World)
4772 b2World.GetWorldAABB = new_instancemethod(_Box2D.b2World_GetWorldAABB,None,b2World)
4773 b2World.CanSleep = new_instancemethod(_Box2D.b2World_CanSleep,None,b2World)
4774 b2World.CreateBody = new_instancemethod(_Box2D.b2World_CreateBody,None,b2World)
4775 b2World.CreateJoint = new_instancemethod(_Box2D.b2World_CreateJoint,None,b2World)
4776 b2World.DestroyBody = new_instancemethod(_Box2D.b2World_DestroyBody,None,b2World)
4777 b2World.DestroyJoint = new_instancemethod(_Box2D.b2World_DestroyJoint,None,b2World)
4778 b2World.Raycast = new_instancemethod(_Box2D.b2World_Raycast,None,b2World)
4779 b2World.RaycastOne = new_instancemethod(_Box2D.b2World_RaycastOne,None,b2World)
4780 b2World.Query = new_instancemethod(_Box2D.b2World_Query,None,b2World)
4781 b2World_swigregister = _Box2D.b2World_swigregister
4782 b2World_swigregister(b2World)
4783
4784 e_unknownController = _Box2D.e_unknownController
4785 e_buoyancyController = _Box2D.e_buoyancyController
4786 e_constantAccelController = _Box2D.e_constantAccelController
4787 e_constantForceController = _Box2D.e_constantForceController
4788 e_gravityController = _Box2D.e_gravityController
4789 e_tensorDampingController = _Box2D.e_tensorDampingController
4791 """A controller edge is used to connect bodies and controllers together in a bipartite graph."""
4792 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
4793 __repr__ = _swig_repr
4794 controller = _swig_property(_Box2D.b2ControllerEdge_controller_get, _Box2D.b2ControllerEdge_controller_set)
4795 body = _swig_property(_Box2D.b2ControllerEdge_body_get, _Box2D.b2ControllerEdge_body_set)
4796 prevBody = _swig_property(_Box2D.b2ControllerEdge_prevBody_get, _Box2D.b2ControllerEdge_prevBody_set)
4797 nextBody = _swig_property(_Box2D.b2ControllerEdge_nextBody_get, _Box2D.b2ControllerEdge_nextBody_set)
4798 prevController = _swig_property(_Box2D.b2ControllerEdge_prevController_get, _Box2D.b2ControllerEdge_prevController_set)
4799 nextController = _swig_property(_Box2D.b2ControllerEdge_nextController_get, _Box2D.b2ControllerEdge_nextController_set)
4801 return """b2ControllerEdge(
4802 body = %s,
4803 controller = %s)"""% tuple(str(a) for a in\
4804 (self.body,self.controller))
4805
4806 __getstate__=_generic_getstate
4807 __setstate__=_generic_setstate
4808
4810 """__init__(self) -> b2ControllerEdge"""
4811 _Box2D.b2ControllerEdge_swiginit(self,_Box2D.new_b2ControllerEdge())
4812 __swig_destroy__ = _Box2D.delete_b2ControllerEdge
4813 b2ControllerEdge_swigregister = _Box2D.b2ControllerEdge_swigregister
4814 b2ControllerEdge_swigregister(b2ControllerEdge)
4815
4817 """Base class for controllers. Controllers are a convience for encapsulating common per-step functionality."""
4818 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
4819 - def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
4820 __repr__ = _swig_repr
4821 __swig_destroy__ = _Box2D.delete_b2Controller
4822 - def Step(self, *args):
4823 """
4824 Step(self, b2TimeStep step)
4825
4826 Controllers override this to implement per-step functionality.
4827 """
4828 return _Box2D.b2Controller_Step(self, *args)
4829
4830 - def Draw(self, *args):
4831 """
4832 Draw(self, b2DebugDraw debugDraw)
4833
4834 Controllers override this to provide debug drawing.
4835 """
4836 return _Box2D.b2Controller_Draw(self, *args)
4837
4838 - def AddBody(self, *args):
4839 """
4840 AddBody(self, b2Body body)
4841
4842 Adds a body to the controller list.
4843 """
4844 return _Box2D.b2Controller_AddBody(self, *args)
4845
4846 - def RemoveBody(self, *args):
4847 """
4848 RemoveBody(self, b2Body body)
4849
4850 Removes a body from the controller list.
4851 """
4852 return _Box2D.b2Controller_RemoveBody(self, *args)
4853
4855 """
4856 Clear(self)
4857
4858 Removes all bodies from the controller list.
4859 """
4860 return _Box2D.b2Controller_Clear(self)
4861
4863 """
4864 GetType(self) -> b2ControllerType
4865
4866 Get the type of the controller.
4867 """
4868 return _Box2D.b2Controller_GetType(self)
4869
4871 """
4872 GetNext(self) -> b2Controller
4873
4874 Get the next controller in the world's body list.
4875 """
4876 return _Box2D.b2Controller_GetNext(self)
4877
4879 """
4880 GetWorld(self) -> b2World
4881
4882 Get the parent world of this body.
4883 """
4884 return _Box2D.b2Controller_GetWorld(self)
4885
4886 - def _GetBodyList(self):
4887 """
4888 _GetBodyList(self) -> b2ControllerEdge
4889
4890 Get the attached body list.
4891 """
4892 return _Box2D.b2Controller__GetBodyList(self)
4893
4895 return "b2Controller()"
4896
4897 __getstate__=no_pickle
4898 __setstate__=_generic_setstate
4899
4901 """__hash__(self) -> int32"""
4902 return _Box2D.b2Controller___hash__(self)
4903
4905 """
4906 Return the name of the controller from:
4907 Unknown, Buoyancy, ConstantAccel, ConstantForce, Gravity, TensorDamping
4908 """
4909 types = { e_unknownController : 'Unknown',
4910 e_buoyancyController : 'Buoyancy',
4911 e_constantAccelController : 'ConstantAccel',
4912 e_constantForceController : 'ConstantForce',
4913 e_gravityController : 'Gravity',
4914 e_tensorDampingController : 'TensorDamping' }
4915 return types[self.GetType()]
4917 """
4918 Return a typecasted version of the controller
4919 """
4920 return (getattr(self, "_as%sController" % self.typeName())) ()
4921 - def GetBodyList(self):
4922 bodyList = []
4923 c_edge = self._GetBodyList()
4924 while c_edge:
4925 bodyList.append(c_edge.body)
4926 c_edge = c_edge.nextBody
4927 bodyList.reverse()
4928 return bodyList
4929
4931 """
4932 Iterates over the bodies in the controller
4933 """
4934 for body in self.bodyList:
4935 yield body
4936
4937 __eq__ = b2ControllerCompare
4938 __ne__ = lambda self,other: not b2ControllerCompare(self,other)
4939 type = property(GetType, None)
4940 bodyList = property(GetBodyList, None)
4941
4943 """_asBuoyancyController(self) -> b2BuoyancyController"""
4944 return _Box2D.b2Controller__asBuoyancyController(self)
4945
4947 """_asConstantAccelController(self) -> b2ConstantAccelController"""
4948 return _Box2D.b2Controller__asConstantAccelController(self)
4949
4951 """_asConstantForceController(self) -> b2ConstantForceController"""
4952 return _Box2D.b2Controller__asConstantForceController(self)
4953
4955 """_asGravityController(self) -> b2GravityController"""
4956 return _Box2D.b2Controller__asGravityController(self)
4957
4959 """_asTensorDampingController(self) -> b2TensorDampingController"""
4960 return _Box2D.b2Controller__asTensorDampingController(self)
4961
4962 b2Controller.Step = new_instancemethod(_Box2D.b2Controller_Step,None,b2Controller)
4963 b2Controller.Draw = new_instancemethod(_Box2D.b2Controller_Draw,None,b2Controller)
4964 b2Controller.AddBody = new_instancemethod(_Box2D.b2Controller_AddBody,None,b2Controller)
4965 b2Controller.RemoveBody = new_instancemethod(_Box2D.b2Controller_RemoveBody,None,b2Controller)
4966 b2Controller.Clear = new_instancemethod(_Box2D.b2Controller_Clear,None,b2Controller)
4967 b2Controller.GetType = new_instancemethod(_Box2D.b2Controller_GetType,None,b2Controller)
4968 b2Controller.GetNext = new_instancemethod(_Box2D.b2Controller_GetNext,None,b2Controller)
4969 b2Controller.GetWorld = new_instancemethod(_Box2D.b2Controller_GetWorld,None,b2Controller)
4970 b2Controller._GetBodyList = new_instancemethod(_Box2D.b2Controller__GetBodyList,None,b2Controller)
4971 b2Controller.__hash__ = new_instancemethod(_Box2D.b2Controller___hash__,None,b2Controller)
4972 b2Controller._asBuoyancyController = new_instancemethod(_Box2D.b2Controller__asBuoyancyController,None,b2Controller)
4973 b2Controller._asConstantAccelController = new_instancemethod(_Box2D.b2Controller__asConstantAccelController,None,b2Controller)
4974 b2Controller._asConstantForceController = new_instancemethod(_Box2D.b2Controller__asConstantForceController,None,b2Controller)
4975 b2Controller._asGravityController = new_instancemethod(_Box2D.b2Controller__asGravityController,None,b2Controller)
4976 b2Controller._asTensorDampingController = new_instancemethod(_Box2D.b2Controller__asTensorDampingController,None,b2Controller)
4977 b2Controller_swigregister = _Box2D.b2Controller_swigregister
4978 b2Controller_swigregister(b2Controller)
4979
4991
4992 b2ControllerDef_swigregister = _Box2D.b2ControllerDef_swigregister
4993 b2ControllerDef_swigregister(b2ControllerDef)
4994
4995 -class b2BodyDef(object):
4996 """A body definition holds all the data needed to construct a rigid body. You can safely re-use body definitions."""
4997 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
4998 __repr__ = _swig_repr
4999 - def __init__(self):
5000 """
5001 __init__(self) -> b2BodyDef
5002
5003 This constructor sets the body definition default values.
5004 """
5005 _Box2D.b2BodyDef_swiginit(self,_Box2D.new_b2BodyDef())
5006 massData = _swig_property(_Box2D.b2BodyDef_massData_get, _Box2D.b2BodyDef_massData_set)
5007 position = _swig_property(_Box2D.b2BodyDef_position_get, _Box2D.b2BodyDef_position_set)
5008 angle = _swig_property(_Box2D.b2BodyDef_angle_get, _Box2D.b2BodyDef_angle_set)
5009 linearDamping = _swig_property(_Box2D.b2BodyDef_linearDamping_get, _Box2D.b2BodyDef_linearDamping_set)
5010 angularDamping = _swig_property(_Box2D.b2BodyDef_angularDamping_get, _Box2D.b2BodyDef_angularDamping_set)
5011 allowSleep = _swig_property(_Box2D.b2BodyDef_allowSleep_get, _Box2D.b2BodyDef_allowSleep_set)
5012 isSleeping = _swig_property(_Box2D.b2BodyDef_isSleeping_get, _Box2D.b2BodyDef_isSleeping_set)
5013 fixedRotation = _swig_property(_Box2D.b2BodyDef_fixedRotation_get, _Box2D.b2BodyDef_fixedRotation_set)
5014 isBullet = _swig_property(_Box2D.b2BodyDef_isBullet_get, _Box2D.b2BodyDef_isBullet_set)
5015 - def __repr__(self):
5016 return """b2BodyDef(
5017 allowSleep = %s,
5018 angle = %s,
5019 angularDamping = %s,
5020 fixedRotation = %s,
5021 isBullet = %s,
5022 isSleeping = %s,
5023 linearDamping = %s,
5024 massData = %s,
5025 position = %s,
5026 userData = %s)"""% tuple(str(a) for a in\
5027 (self.allowSleep,self.angle,self.angularDamping,self.fixedRotation,self.isBullet,self.isSleeping,self.linearDamping,self.massData,self.position,self.userData))
5028
5029 __getstate__=_generic_getstate
5030 __setstate__=_generic_setstate
5031
5032 - def GetUserData(self):
5033 """GetUserData(self) -> PyObject"""
5034 return _Box2D.b2BodyDef_GetUserData(self)
5035
5036 - def SetUserData(self, *args):
5037 """SetUserData(self, PyObject data)"""
5038 return _Box2D.b2BodyDef_SetUserData(self, *args)
5039
5040 - def ClearUserData(self):
5041 """ClearUserData(self)"""
5042 return _Box2D.b2BodyDef_ClearUserData(self)
5043
5044 userData = property(GetUserData, SetUserData)
5045 - def __del__(self):
5047
5048 __swig_destroy__ = _Box2D.delete_b2BodyDef
5049 b2BodyDef.GetUserData = new_instancemethod(_Box2D.b2BodyDef_GetUserData,None,b2BodyDef)
5050 b2BodyDef.SetUserData = new_instancemethod(_Box2D.b2BodyDef_SetUserData,None,b2BodyDef)
5051 b2BodyDef.ClearUserData = new_instancemethod(_Box2D.b2BodyDef_ClearUserData,None,b2BodyDef)
5052 b2BodyDef_swigregister = _Box2D.b2BodyDef_swigregister
5053 b2BodyDef_swigregister(b2BodyDef)
5054
5055 -class b2Body(object):
5056 """A rigid body."""
5057 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
5058 - def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
5059 __repr__ = _swig_repr
5060 - def SetMass(self, *args):
5061 """
5062 SetMass(self, b2MassData massData)
5063
5064 Set the mass properties. Note that this changes the center of mass position. If you are not sure how to compute mass properties, use SetMassFromShapes. The inertia tensor is assumed to be relative to the center of mass.
5065
5066 Parameters:
5067 -----------
5068
5069 massData: the mass properties.
5070 """
5071 return _Box2D.b2Body_SetMass(self, *args)
5072
5074 """
5075 SetMassFromShapes(self)
5076
5077 Compute the mass properties from the attached shapes. You typically call this after adding all the shapes. If you add or remove shapes later, you may want to call this again. Note that this changes the center of mass position.
5078 """
5079 return _Box2D.b2Body_SetMassFromShapes(self)
5080
5082 """
5083 SetXForm(self, b2Vec2 position, float32 angle) -> bool
5084
5085 Set the position of the body's origin and rotation (radians). This breaks any contacts and wakes the other bodies.
5086
5087 Parameters:
5088 -----------
5089
5090 position: the new world position of the body's origin (not necessarily the center of mass).
5091
5092 angle: the new world rotation angle of the body in radians.
5093
5094 false if the movement put a shape outside the world. In this case the body is automatically frozen.
5095 """
5096 return _Box2D.b2Body_SetXForm(self, *args)
5097
5099 """
5100 GetXForm(self) -> b2XForm
5101
5102 Get the body transform for the body's origin.
5103 the world transform of the body's origin.
5104 """
5105 return _Box2D.b2Body_GetXForm(self)
5106
5107 - def GetPosition(self):
5108 """
5109 GetPosition(self) -> b2Vec2
5110
5111 Get the world body origin position.
5112 the world position of the body's origin.
5113 """
5114 return _Box2D.b2Body_GetPosition(self)
5115
5116 - def GetAngle(self):
5117 """
5118 GetAngle(self) -> float32
5119
5120 Get the angle in radians.
5121 the current world rotation angle in radians.
5122 """
5123 return _Box2D.b2Body_GetAngle(self)
5124
5125 - def GetLinearDamping(self):
5126 """
5127 GetLinearDamping(self) -> float32
5128
5129 Get the linear damping.
5130 """
5131 return _Box2D.b2Body_GetLinearDamping(self)
5132
5134 """
5135 GetAngularDamping(self) -> float32
5136
5137 Get the angular damping.
5138 """
5139 return _Box2D.b2Body_GetAngularDamping(self)
5140
5141 - def GetWorldCenter(self):
5142 """
5143 GetWorldCenter(self) -> b2Vec2
5144
5145 Get the world position of the center of mass.
5146 """
5147 return _Box2D.b2Body_GetWorldCenter(self)
5148
5149 - def GetLocalCenter(self):
5150 """
5151 GetLocalCenter(self) -> b2Vec2
5152
5153 Get the local position of the center of mass.
5154 """
5155 return _Box2D.b2Body_GetLocalCenter(self)
5156
5157 - def SetLinearVelocity(self, *args):
5158 """
5159 SetLinearVelocity(self, b2Vec2 v)
5160
5161 Set the linear velocity of the center of mass.
5162
5163 Parameters:
5164 -----------
5165
5166 v: the new linear velocity of the center of mass.
5167 """
5168 return _Box2D.b2Body_SetLinearVelocity(self, *args)
5169
5171 """
5172 GetLinearVelocity(self) -> b2Vec2
5173
5174 Get the linear velocity of the center of mass.
5175 the linear velocity of the center of mass.
5176 """
5177 return _Box2D.b2Body_GetLinearVelocity(self)
5178
5179 - def SetAngularVelocity(self, *args):
5180 """
5181 SetAngularVelocity(self, float32 omega)
5182
5183 Set the angular velocity.
5184
5185 Parameters:
5186 -----------
5187
5188 omega: the new angular velocity in radians/second.
5189 """
5190 return _Box2D.b2Body_SetAngularVelocity(self, *args)
5191
5193 """
5194 GetAngularVelocity(self) -> float32
5195
5196 Get the angular velocity.
5197 the angular velocity in radians/second.
5198 """
5199 return _Box2D.b2Body_GetAngularVelocity(self)
5200
5201 - def ApplyForce(self, *args):
5202 """
5203 ApplyForce(self, b2Vec2 force, b2Vec2 point)
5204
5205 Apply a force at a world point. If the force is not applied at the center of mass, it will generate a torque and affect the angular velocity. This wakes up the body.
5206
5207 Parameters:
5208 -----------
5209
5210 force: the world force vector, usually in Newtons (N).
5211
5212 point: the world position of the point of application.
5213 """
5214 return _Box2D.b2Body_ApplyForce(self, *args)
5215
5216 - def ApplyTorque(self, *args):
5217 """
5218 ApplyTorque(self, float32 torque)
5219
5220 Apply a torque. This affects the angular velocity without affecting the linear velocity of the center of mass. This wakes up the body.
5221
5222 Parameters:
5223 -----------
5224
5225 torque: about the z-axis (out of the screen), usually in N-m.
5226 """
5227 return _Box2D.b2Body_ApplyTorque(self, *args)
5228
5229 - def ApplyImpulse(self, *args):
5230 """
5231 ApplyImpulse(self, b2Vec2 impulse, b2Vec2 point)
5232
5233 Apply an impulse at a point. This immediately modifies the velocity. It also modifies the angular velocity if the point of application is not at the center of mass. This wakes up the body.
5234
5235 Parameters:
5236 -----------
5237
5238 impulse: the world impulse vector, usually in N-seconds or kg-m/s.
5239
5240 point: the world position of the point of application.
5241 """
5242 return _Box2D.b2Body_ApplyImpulse(self, *args)
5243
5244 - def GetMass(self):
5245 """
5246 GetMass(self) -> float32
5247
5248 Get the total mass of the body.
5249 the mass, usually in kilograms (kg).
5250 """
5251 return _Box2D.b2Body_GetMass(self)
5252
5253 - def GetInertia(self):
5254 """
5255 GetInertia(self) -> float32
5256
5257 Get the central rotational inertia of the body.
5258 the rotational inertia, usually in kg-m^2.
5259 """
5260 return _Box2D.b2Body_GetInertia(self)
5261
5262 - def GetWorldPoint(self, *args):
5263 """
5264 GetWorldPoint(self, b2Vec2 localPoint) -> b2Vec2
5265
5266 Get the world coordinates of a point given the local coordinates.
5267
5268 Parameters:
5269 -----------
5270
5271 localPoint: a point on the body measured relative the the body's origin.
5272
5273 the same point expressed in world coordinates.
5274 """
5275 return _Box2D.b2Body_GetWorldPoint(self, *args)
5276
5277 - def GetWorldVector(self, *args):
5278 """
5279 GetWorldVector(self, b2Vec2 localVector) -> b2Vec2
5280
5281 Get the world coordinates of a vector given the local coordinates.
5282
5283 Parameters:
5284 -----------
5285
5286 localVector: a vector fixed in the body.
5287
5288 the same vector expressed in world coordinates.
5289 """
5290 return _Box2D.b2Body_GetWorldVector(self, *args)
5291
5292 - def GetLocalPoint(self, *args):
5293 """
5294 GetLocalPoint(self, b2Vec2 worldPoint) -> b2Vec2
5295
5296 Gets a local point relative to the body's origin given a world point.
5297
5298 Parameters:
5299 -----------
5300
5301 a: point in world coordinates.
5302
5303 the corresponding local point relative to the body's origin.
5304 """
5305 return _Box2D.b2Body_GetLocalPoint(self, *args)
5306
5307 - def GetLocalVector(self, *args):
5308 """
5309 GetLocalVector(self, b2Vec2 worldVector) -> b2Vec2
5310
5311 Gets a local vector given a world vector.
5312
5313 Parameters:
5314 -----------
5315
5316 a: vector in world coordinates.
5317
5318 the corresponding local vector.
5319 """
5320 return _Box2D.b2Body_GetLocalVector(self, *args)
5321
5323 """
5324 GetLinearVelocityFromWorldPoint(self, b2Vec2 worldPoint) -> b2Vec2
5325
5326 Get the world linear velocity of a world point attached to this body.
5327
5328 Parameters:
5329 -----------
5330
5331 a: point in world coordinates.
5332
5333 the world velocity of a point.
5334 """
5335 return _Box2D.b2Body_GetLinearVelocityFromWorldPoint(self, *args)
5336
5338 """
5339 GetLinearVelocityFromLocalPoint(self, b2Vec2 localPoint) -> b2Vec2
5340
5341 Get the world velocity of a local point.
5342
5343 Parameters:
5344 -----------
5345
5346 a: point in local coordinates.
5347
5348 the world velocity of a point.
5349 """
5350 return _Box2D.b2Body_GetLinearVelocityFromLocalPoint(self, *args)
5351
5352 - def IsBullet(self):
5353 """
5354 IsBullet(self) -> bool
5355
5356 Is this body treated like a bullet for continuous collision detection?
5357 """
5358 return _Box2D.b2Body_IsBullet(self)
5359
5360 - def SetBullet(self, *args):
5361 """
5362 SetBullet(self, bool flag)
5363
5364 Should this body be treated like a bullet for continuous collision detection?
5365 """
5366 return _Box2D.b2Body_SetBullet(self, *args)
5367
5368 - def IsStatic(self):
5369 """
5370 IsStatic(self) -> bool
5371
5372 Is this body static (immovable)?
5373 """
5374 return _Box2D.b2Body_IsStatic(self)
5375
5376 - def IsDynamic(self):
5377 """
5378 IsDynamic(self) -> bool
5379
5380 Is this body dynamic (movable)?
5381 """
5382 return _Box2D.b2Body_IsDynamic(self)
5383
5384 - def IsFrozen(self):
5385 """
5386 IsFrozen(self) -> bool
5387
5388 Is this body frozen?
5389 """
5390 return _Box2D.b2Body_IsFrozen(self)
5391
5392 - def IsSleeping(self):
5393 """
5394 IsSleeping(self) -> bool
5395
5396 Is this body sleeping (not simulating).
5397 """
5398 return _Box2D.b2Body_IsSleeping(self)
5399
5400 - def AllowSleeping(self, *args):
5401 """
5402 AllowSleeping(self, bool flag)
5403
5404 You can disable sleeping on this body.
5405 """
5406 return _Box2D.b2Body_AllowSleeping(self, *args)
5407
5408 - def CanSleep(self):
5409 """
5410 CanSleep(self) -> bool
5411
5412 Get whether or not this body is allowed to sleep.
5413 """
5414 return _Box2D.b2Body_CanSleep(self)
5415
5416 - def IsRotationFixed(self):
5417 """
5418 IsRotationFixed(self) -> bool
5419
5420 Get whether or not this body is allowed to rotate.
5421 """
5422 return _Box2D.b2Body_IsRotationFixed(self)
5423
5425 """
5426 WakeUp(self)
5427
5428 Wake up this body so it will begin simulating.
5429 """
5430 return _Box2D.b2Body_WakeUp(self)
5431
5432 - def PutToSleep(self):
5433 """
5434 PutToSleep(self)
5435
5436 Put this body to sleep so it will stop simulating. This also sets the velocity to zero.
5437 """
5438 return _Box2D.b2Body_PutToSleep(self)
5439
5440 - def _GetShapeList(self):
5441 """
5442 _GetShapeList(self) -> b2Shape
5443
5444 Get the list of all shapes attached to this body.
5445 """
5446 return _Box2D.b2Body__GetShapeList(self)
5447
5448 - def GetJointList(self):
5449 """
5450 GetJointList(self) -> b2JointEdge
5451
5452 Get the list of all joints attached to this body.
5453 """
5454 return _Box2D.b2Body_GetJointList(self)
5455
5457 """
5458 GetControllerList(self) -> b2ControllerEdge
5459
5460 Get the list of all controllers attached to this body.
5461 """
5462 return _Box2D.b2Body_GetControllerList(self)
5463
5464 - def GetNext(self):
5465 """
5466 GetNext(self) -> b2Body
5467
5468 Get the next body in the world's body list.
5469 """
5470 return _Box2D.b2Body_GetNext(self)
5471
5472 - def GetWorld(self):
5473 """
5474 GetWorld(self) -> b2World
5475
5476 Get the parent world of this body.
5477 """
5478 return _Box2D.b2Body_GetWorld(self)
5479
5480 - def __repr__(self):
5481 return """b2Body(
5482 allowSleep = %s,
5483 angle = %s,
5484 angularDamping = %s,
5485 angularVelocity = %s,
5486 fixedRotation = %s,
5487 isBullet = %s,
5488 isSleeping = %s,
5489 linearDamping = %s,
5490 linearVelocity = %s,
5491 massData = %s,
5492 position = %s,
5493 userData = %s,
5494 GetInertia() = %s,
5495 GetLocalCenter() = %s,
5496 GetMass() = %s,
5497 GetWorldCenter() = %s,
5498 GetXForm() = %s,
5499 IsBullet() = %s,
5500 IsDynamic() = %s,
5501 IsFrozen() = %s,
5502 IsRotationFixed() = %s,
5503 IsSleeping() = %s,
5504 IsStatic() = %s)"""% tuple(str(a) for a in\
5505 (self.allowSleep,self.angle,self.angularDamping,self.angularVelocity,self.fixedRotation,self.isBullet,self.isSleeping,self.linearDamping,self.linearVelocity,self.massData,self.position,self.userData,self.GetInertia(),self.GetLocalCenter(),self.GetMass(),self.GetWorldCenter(),self.GetXForm(),self.IsBullet(),self.IsDynamic(),self.IsFrozen(),self.IsRotationFixed(),self.IsSleeping(),self.IsStatic()))
5506
5507 __getstate__=_pickle_body_getstate
5508 __setstate__=_pickle_factory_set
5509 _pickle_finalize=_pickle_finalize
5510
5511 - def DestroyShape(self, *args):
5512 """
5513 DestroyShape(self, b2Shape shape)
5514
5515 Destroy a shape. This removes the shape from the broad-phase and therefore destroys any contacts associated with this shape. All shapes attached to a body are implicitly destroyed when the body is destroyed.
5516
5517 Parameters:
5518 -----------
5519
5520 shape: the shape to be removed.
5521
5522 WARNING:
5523 This function is locked during callbacks.
5524 """
5525 return _Box2D.b2Body_DestroyShape(self, *args)
5526
5527 - def CreateShape(self, *args):
5528 """
5529 CreateShape(self, b2ShapeDef defn) -> b2Shape
5530
5531 Creates a shape and attach it to this body.
5532
5533 Parameters:
5534 -----------
5535
5536 shapeDef: the shape definition.
5537
5538 WARNING:
5539 This function is locked during callbacks.
5540 """
5541 return _Box2D.b2Body_CreateShape(self, *args)
5542
5543 - def GetUserData(self):
5544 """
5545 GetUserData(self) -> PyObject
5546
5547 Get the user data pointer that was provided in the body definition.
5548 """
5549 return _Box2D.b2Body_GetUserData(self)
5550
5551 - def SetUserData(self, *args):
5552 """
5553 SetUserData(self, PyObject data)
5554
5555 Set the user data. Use this to store your application specific data.
5556 """
5557 return _Box2D.b2Body_SetUserData(self, *args)
5558
5559 - def ClearUserData(self):
5560 """ClearUserData(self)"""
5561 return _Box2D.b2Body_ClearUserData(self)
5562
5563 userData = property(GetUserData, SetUserData)
5564
5565 - def __hash__(self):
5566 """__hash__(self) -> int32"""
5567 return _Box2D.b2Body___hash__(self)
5568
5569 __eq__ = b2BodyCompare
5570 __ne__ = lambda self,other: not b2BodyCompare(self,other)
5571
5572 - def setAngle(self, angle):
5573 """
5574 Set the angle without altering the position
5575
5576 angle in radians.
5577 """
5578 self.SetXForm(self.position, angle)
5579 - def setPosition(self, position):
5580 """
5581 Set the position without altering the angle
5582 """
5583 self.SetXForm(position, self.GetAngle())
5584
5585 - def getMassData(self):
5586 """
5587 Get a b2MassData object that represents this b2Body
5588
5589 NOTE: To just get the mass, use body.mass (body.GetMass())
5590 """
5591
5592 ret = b2MassData()
5593 ret.mass = self.GetMass()
5594 ret.I = self.GetInertia()
5595 ret.center=self.GetLocalCenter()
5596 return ret
5597
5598 - def GetShapeList(self, asType=True):
5599 """
5600 Get a list of the shapes in this body
5601
5602 Defaults to returning the typecasted objects.
5603
5604 e.g., if there is a b2CircleShape and a b2PolygonShape:
5605 GetShapeList(True) = [b2CircleShape, b2PolygonShape]
5606 GetShapeList(False)= [b2Shape, b2Shape]
5607 """
5608 shapeList = []
5609 shape = self._GetShapeList()
5610 while shape:
5611 if asType:
5612 shape=shape.getAsType()
5613 shapeList.append(shape)
5614 shape = shape.GetNext()
5615 shapeList.reverse()
5616 return shapeList
5617
5618 - def __iter__(self):
5619 """
5620 Iterates over the shapes in the body
5621 """
5622 for shape in self.shapeList:
5623 yield shape
5624
5625 massData = property(getMassData , SetMass)
5626 position = property(GetPosition , setPosition)
5627 angle = property(GetAngle , setAngle)
5628 linearDamping = property(GetLinearDamping , None)
5629 angularDamping= property(GetAngularDamping , None)
5630 allowSleep = property(CanSleep , AllowSleeping)
5631 isSleeping = property(IsSleeping , None)
5632 fixedRotation = property(IsRotationFixed , None)
5633 isBullet = property(IsBullet , SetBullet)
5634 angularVelocity=property(GetAngularVelocity , SetAngularVelocity)
5635 linearVelocity =property(GetLinearVelocity , SetLinearVelocity)
5636 shapeList =property(GetShapeList , None)
5637
5638 b2Body.SetMass = new_instancemethod(_Box2D.b2Body_SetMass,None,b2Body)
5639 b2Body.SetMassFromShapes = new_instancemethod(_Box2D.b2Body_SetMassFromShapes,None,b2Body)
5640 b2Body.SetXForm = new_instancemethod(_Box2D.b2Body_SetXForm,None,b2Body)
5641 b2Body.GetXForm = new_instancemethod(_Box2D.b2Body_GetXForm,None,b2Body)
5642 b2Body.GetPosition = new_instancemethod(_Box2D.b2Body_GetPosition,None,b2Body)
5643 b2Body.GetAngle = new_instancemethod(_Box2D.b2Body_GetAngle,None,b2Body)
5644 b2Body.GetLinearDamping = new_instancemethod(_Box2D.b2Body_GetLinearDamping,None,b2Body)
5645 b2Body.GetAngularDamping = new_instancemethod(_Box2D.b2Body_GetAngularDamping,None,b2Body)
5646 b2Body.GetWorldCenter = new_instancemethod(_Box2D.b2Body_GetWorldCenter,None,b2Body)
5647 b2Body.GetLocalCenter = new_instancemethod(_Box2D.b2Body_GetLocalCenter,None,b2Body)
5648 b2Body.SetLinearVelocity = new_instancemethod(_Box2D.b2Body_SetLinearVelocity,None,b2Body)
5649 b2Body.GetLinearVelocity = new_instancemethod(_Box2D.b2Body_GetLinearVelocity,None,b2Body)
5650 b2Body.SetAngularVelocity = new_instancemethod(_Box2D.b2Body_SetAngularVelocity,None,b2Body)
5651 b2Body.GetAngularVelocity = new_instancemethod(_Box2D.b2Body_GetAngularVelocity,None,b2Body)
5652 b2Body.ApplyForce = new_instancemethod(_Box2D.b2Body_ApplyForce,None,b2Body)
5653 b2Body.ApplyTorque = new_instancemethod(_Box2D.b2Body_ApplyTorque,None,b2Body)
5654 b2Body.ApplyImpulse = new_instancemethod(_Box2D.b2Body_ApplyImpulse,None,b2Body)
5655 b2Body.GetMass = new_instancemethod(_Box2D.b2Body_GetMass,None,b2Body)
5656 b2Body.GetInertia = new_instancemethod(_Box2D.b2Body_GetInertia,None,b2Body)
5657 b2Body.GetWorldPoint = new_instancemethod(_Box2D.b2Body_GetWorldPoint,None,b2Body)
5658 b2Body.GetWorldVector = new_instancemethod(_Box2D.b2Body_GetWorldVector,None,b2Body)
5659 b2Body.GetLocalPoint = new_instancemethod(_Box2D.b2Body_GetLocalPoint,None,b2Body)
5660 b2Body.GetLocalVector = new_instancemethod(_Box2D.b2Body_GetLocalVector,None,b2Body)
5661 b2Body.GetLinearVelocityFromWorldPoint = new_instancemethod(_Box2D.b2Body_GetLinearVelocityFromWorldPoint,None,b2Body)
5662 b2Body.GetLinearVelocityFromLocalPoint = new_instancemethod(_Box2D.b2Body_GetLinearVelocityFromLocalPoint,None,b2Body)
5663 b2Body.IsBullet = new_instancemethod(_Box2D.b2Body_IsBullet,None,b2Body)
5664 b2Body.SetBullet = new_instancemethod(_Box2D.b2Body_SetBullet,None,b2Body)
5665 b2Body.IsStatic = new_instancemethod(_Box2D.b2Body_IsStatic,None,b2Body)
5666 b2Body.IsDynamic = new_instancemethod(_Box2D.b2Body_IsDynamic,None,b2Body)
5667 b2Body.IsFrozen = new_instancemethod(_Box2D.b2Body_IsFrozen,None,b2Body)
5668 b2Body.IsSleeping = new_instancemethod(_Box2D.b2Body_IsSleeping,None,b2Body)
5669 b2Body.AllowSleeping = new_instancemethod(_Box2D.b2Body_AllowSleeping,None,b2Body)
5670 b2Body.CanSleep = new_instancemethod(_Box2D.b2Body_CanSleep,None,b2Body)
5671 b2Body.IsRotationFixed = new_instancemethod(_Box2D.b2Body_IsRotationFixed,None,b2Body)
5672 b2Body.WakeUp = new_instancemethod(_Box2D.b2Body_WakeUp,None,b2Body)
5673 b2Body.PutToSleep = new_instancemethod(_Box2D.b2Body_PutToSleep,None,b2Body)
5674 b2Body._GetShapeList = new_instancemethod(_Box2D.b2Body__GetShapeList,None,b2Body)
5675 b2Body.GetJointList = new_instancemethod(_Box2D.b2Body_GetJointList,None,b2Body)
5676 b2Body.GetControllerList = new_instancemethod(_Box2D.b2Body_GetControllerList,None,b2Body)
5677 b2Body.GetNext = new_instancemethod(_Box2D.b2Body_GetNext,None,b2Body)
5678 b2Body.GetWorld = new_instancemethod(_Box2D.b2Body_GetWorld,None,b2Body)
5679 b2Body.DestroyShape = new_instancemethod(_Box2D.b2Body_DestroyShape,None,b2Body)
5680 b2Body.CreateShape = new_instancemethod(_Box2D.b2Body_CreateShape,None,b2Body)
5681 b2Body.GetUserData = new_instancemethod(_Box2D.b2Body_GetUserData,None,b2Body)
5682 b2Body.SetUserData = new_instancemethod(_Box2D.b2Body_SetUserData,None,b2Body)
5683 b2Body.ClearUserData = new_instancemethod(_Box2D.b2Body_ClearUserData,None,b2Body)
5684 b2Body.__hash__ = new_instancemethod(_Box2D.b2Body___hash__,None,b2Body)
5685 b2Body_swigregister = _Box2D.b2Body_swigregister
5686 b2Body_swigregister(b2Body)
5687
5689 """Calculates buoyancy forces for fluids in the form of a half plane."""
5690 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
5691 - def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
5692 __repr__ = _swig_repr
5693 normal = _swig_property(_Box2D.b2BuoyancyController_normal_get, _Box2D.b2BuoyancyController_normal_set)
5694 offset = _swig_property(_Box2D.b2BuoyancyController_offset_get, _Box2D.b2BuoyancyController_offset_set)
5695 density = _swig_property(_Box2D.b2BuoyancyController_density_get, _Box2D.b2BuoyancyController_density_set)
5696 velocity = _swig_property(_Box2D.b2BuoyancyController_velocity_get, _Box2D.b2BuoyancyController_velocity_set)
5697 linearDrag = _swig_property(_Box2D.b2BuoyancyController_linearDrag_get, _Box2D.b2BuoyancyController_linearDrag_set)
5698 angularDrag = _swig_property(_Box2D.b2BuoyancyController_angularDrag_get, _Box2D.b2BuoyancyController_angularDrag_set)
5699 useDensity = _swig_property(_Box2D.b2BuoyancyController_useDensity_get, _Box2D.b2BuoyancyController_useDensity_set)
5700 useWorldGravity = _swig_property(_Box2D.b2BuoyancyController_useWorldGravity_get, _Box2D.b2BuoyancyController_useWorldGravity_set)
5701 gravity = _swig_property(_Box2D.b2BuoyancyController_gravity_get, _Box2D.b2BuoyancyController_gravity_set)
5703 return """b2BuoyancyController(
5704 angularDrag = %s,
5705 density = %s,
5706 gravity = %s,
5707 linearDrag = %s,
5708 normal = %s,
5709 offset = %s,
5710 useDensity = %s,
5711 useWorldGravity = %s,
5712 velocity = %s)"""% tuple(str(a) for a in\
5713 (self.angularDrag,self.density,self.gravity,self.linearDrag,self.normal,self.offset,self.useDensity,self.useWorldGravity,self.velocity))
5714
5715 __getstate__=_pickle_get_controller
5716 __setstate__=_pickle_factory_set
5717 _pickle_finalize=_pickle_finalize_controller
5718
5719 __swig_destroy__ = _Box2D.delete_b2BuoyancyController
5720 b2BuoyancyController_swigregister = _Box2D.b2BuoyancyController_swigregister
5721 b2BuoyancyController_swigregister(b2BuoyancyController)
5722
5724 """This class is used to build buoyancy controllers."""
5725 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
5726 __repr__ = _swig_repr
5727 normal = _swig_property(_Box2D.b2BuoyancyControllerDef_normal_get, _Box2D.b2BuoyancyControllerDef_normal_set)
5728 offset = _swig_property(_Box2D.b2BuoyancyControllerDef_offset_get, _Box2D.b2BuoyancyControllerDef_offset_set)
5729 density = _swig_property(_Box2D.b2BuoyancyControllerDef_density_get, _Box2D.b2BuoyancyControllerDef_density_set)
5730 velocity = _swig_property(_Box2D.b2BuoyancyControllerDef_velocity_get, _Box2D.b2BuoyancyControllerDef_velocity_set)
5731 linearDrag = _swig_property(_Box2D.b2BuoyancyControllerDef_linearDrag_get, _Box2D.b2BuoyancyControllerDef_linearDrag_set)
5732 angularDrag = _swig_property(_Box2D.b2BuoyancyControllerDef_angularDrag_get, _Box2D.b2BuoyancyControllerDef_angularDrag_set)
5733 useDensity = _swig_property(_Box2D.b2BuoyancyControllerDef_useDensity_get, _Box2D.b2BuoyancyControllerDef_useDensity_set)
5734 useWorldGravity = _swig_property(_Box2D.b2BuoyancyControllerDef_useWorldGravity_get, _Box2D.b2BuoyancyControllerDef_useWorldGravity_set)
5735 gravity = _swig_property(_Box2D.b2BuoyancyControllerDef_gravity_get, _Box2D.b2BuoyancyControllerDef_gravity_set)
5737 """
5738 __init__(self) -> b2BuoyancyControllerDef
5739
5740 This class is used to build buoyancy controllers.
5741 """
5742 _Box2D.b2BuoyancyControllerDef_swiginit(self,_Box2D.new_b2BuoyancyControllerDef())
5744 return """b2BuoyancyControllerDef(
5745 angularDrag = %s,
5746 density = %s,
5747 gravity = %s,
5748 linearDrag = %s,
5749 normal = %s,
5750 offset = %s,
5751 useDensity = %s,
5752 useWorldGravity = %s,
5753 velocity = %s)"""% tuple(str(a) for a in\
5754 (self.angularDrag,self.density,self.gravity,self.linearDrag,self.normal,self.offset,self.useDensity,self.useWorldGravity,self.velocity))
5755
5756 __getstate__=_generic_getstate
5757 __setstate__=_generic_setstate
5758
5759 __swig_destroy__ = _Box2D.delete_b2BuoyancyControllerDef
5760 b2BuoyancyControllerDef_swigregister = _Box2D.b2BuoyancyControllerDef_swigregister
5761 b2BuoyancyControllerDef_swigregister(b2BuoyancyControllerDef)
5762
5779 b2ConstantAccelController_swigregister = _Box2D.b2ConstantAccelController_swigregister
5780 b2ConstantAccelController_swigregister(b2ConstantAccelController)
5781
5783 """This class is used to build constant acceleration controllers."""
5784 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
5785 __repr__ = _swig_repr
5786 A = _swig_property(_Box2D.b2ConstantAccelControllerDef_A_get, _Box2D.b2ConstantAccelControllerDef_A_set)
5788 return """b2ConstantAccelControllerDef(
5789 A = %s)"""% tuple(str(a) for a in\
5790 (self.A))
5791
5792 __getstate__=_generic_getstate
5793 __setstate__=_generic_setstate
5794
5796 """__init__(self) -> b2ConstantAccelControllerDef"""
5797 _Box2D.b2ConstantAccelControllerDef_swiginit(self,_Box2D.new_b2ConstantAccelControllerDef())
5798 __swig_destroy__ = _Box2D.delete_b2ConstantAccelControllerDef
5799 b2ConstantAccelControllerDef_swigregister = _Box2D.b2ConstantAccelControllerDef_swigregister
5800 b2ConstantAccelControllerDef_swigregister(b2ConstantAccelControllerDef)
5801
5818 b2ConstantForceController_swigregister = _Box2D.b2ConstantForceController_swigregister
5819 b2ConstantForceController_swigregister(b2ConstantForceController)
5820
5822 """This class is used to build constant force controllers."""
5823 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
5824 __repr__ = _swig_repr
5825 F = _swig_property(_Box2D.b2ConstantForceControllerDef_F_get, _Box2D.b2ConstantForceControllerDef_F_set)
5827 return """b2ConstantForceControllerDef(
5828 F = %s)"""% tuple(str(a) for a in\
5829 (self.F))
5830
5831 __getstate__=_generic_getstate
5832 __setstate__=_generic_setstate
5833
5835 """__init__(self) -> b2ConstantForceControllerDef"""
5836 _Box2D.b2ConstantForceControllerDef_swiginit(self,_Box2D.new_b2ConstantForceControllerDef())
5837 __swig_destroy__ = _Box2D.delete_b2ConstantForceControllerDef
5838 b2ConstantForceControllerDef_swigregister = _Box2D.b2ConstantForceControllerDef_swigregister
5839 b2ConstantForceControllerDef_swigregister(b2ConstantForceControllerDef)
5840
5842 """Applies simplified gravity between every pair of bodies."""
5843 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
5844 - def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
5845 __repr__ = _swig_repr
5846 G = _swig_property(_Box2D.b2GravityController_G_get, _Box2D.b2GravityController_G_set)
5847 invSqr = _swig_property(_Box2D.b2GravityController_invSqr_get, _Box2D.b2GravityController_invSqr_set)
5849 return """b2GravityController(
5850 G = %s,
5851 invSqr = %s)"""% tuple(str(a) for a in\
5852 (self.G,self.invSqr))
5853
5854 __getstate__=_pickle_get_controller
5855 __setstate__=_pickle_factory_set
5856 _pickle_finalize=_pickle_finalize_controller
5857
5858 __swig_destroy__ = _Box2D.delete_b2GravityController
5859 b2GravityController_swigregister = _Box2D.b2GravityController_swigregister
5860 b2GravityController_swigregister(b2GravityController)
5861
5863 """This class is used to build gravity controllers."""
5864 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
5865 __repr__ = _swig_repr
5866 G = _swig_property(_Box2D.b2GravityControllerDef_G_get, _Box2D.b2GravityControllerDef_G_set)
5867 invSqr = _swig_property(_Box2D.b2GravityControllerDef_invSqr_get, _Box2D.b2GravityControllerDef_invSqr_set)
5869 return """b2GravityControllerDef(
5870 G = %s,
5871 invSqr = %s)"""% tuple(str(a) for a in\
5872 (self.G,self.invSqr))
5873
5874 __getstate__=_generic_getstate
5875 __setstate__=_generic_setstate
5876
5878 """__init__(self) -> b2GravityControllerDef"""
5879 _Box2D.b2GravityControllerDef_swiginit(self,_Box2D.new_b2GravityControllerDef())
5880 __swig_destroy__ = _Box2D.delete_b2GravityControllerDef
5881 b2GravityControllerDef_swigregister = _Box2D.b2GravityControllerDef_swigregister
5882 b2GravityControllerDef_swigregister(b2GravityControllerDef)
5883
5885 """Applies top down linear damping to the controlled bodies The damping is calculated by multiplying velocity by a matrix in local co-ordinates."""
5886 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
5887 - def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
5888 __repr__ = _swig_repr
5889 T = _swig_property(_Box2D.b2TensorDampingController_T_get, _Box2D.b2TensorDampingController_T_set)
5890 maxTimestep = _swig_property(_Box2D.b2TensorDampingController_maxTimestep_get, _Box2D.b2TensorDampingController_maxTimestep_set)
5892 return """b2TensorDampingController(
5893 T = %s,
5894 maxTimestep = %s)"""% tuple(str(a) for a in\
5895 (self.T,self.maxTimestep))
5896
5897 __getstate__=_pickle_get_controller
5898 __setstate__=_pickle_factory_set
5899 _pickle_finalize=_pickle_finalize_controller
5900
5901 __swig_destroy__ = _Box2D.delete_b2TensorDampingController
5902 b2TensorDampingController_swigregister = _Box2D.b2TensorDampingController_swigregister
5903 b2TensorDampingController_swigregister(b2TensorDampingController)
5904
5906 """This class is used to build tensor damping controllers."""
5907 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
5908 __repr__ = _swig_repr
5909 T = _swig_property(_Box2D.b2TensorDampingControllerDef_T_get, _Box2D.b2TensorDampingControllerDef_T_set)
5910 maxTimestep = _swig_property(_Box2D.b2TensorDampingControllerDef_maxTimestep_get, _Box2D.b2TensorDampingControllerDef_maxTimestep_set)
5912 """
5913 SetAxisAligned(self, float32 xDamping, float32 yDamping)
5914
5915 Sets damping independantly along the x and y axes.
5916 """
5917 return _Box2D.b2TensorDampingControllerDef_SetAxisAligned(self, *args)
5918
5920 return """b2TensorDampingControllerDef(
5921 T = %s,
5922 maxTimestep = %s)"""% tuple(str(a) for a in\
5923 (self.T,self.maxTimestep))
5924
5925 __getstate__=_generic_getstate
5926 __setstate__=_generic_setstate
5927
5929 """__init__(self) -> b2TensorDampingControllerDef"""
5930 _Box2D.b2TensorDampingControllerDef_swiginit(self,_Box2D.new_b2TensorDampingControllerDef())
5931 __swig_destroy__ = _Box2D.delete_b2TensorDampingControllerDef
5932 b2TensorDampingControllerDef.SetAxisAligned = new_instancemethod(_Box2D.b2TensorDampingControllerDef_SetAxisAligned,None,b2TensorDampingControllerDef)
5933 b2TensorDampingControllerDef_swigregister = _Box2D.b2TensorDampingControllerDef_swigregister
5934 b2TensorDampingControllerDef_swigregister(b2TensorDampingControllerDef)
5935
5937 """
5938 Distance joint definition. This requires defining an anchor point on both bodies and the non-zero length of the distance joint. The definition uses local anchor points so that the initial configuration can violate the constraint slightly. This helps when saving and loading a game.
5939 WARNING:
5940 Do not use a zero or short length.
5941 """
5942 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
5943 __repr__ = _swig_repr
5945 """
5946 __init__(self) -> b2DistanceJointDef
5947
5948 Distance joint definition. This requires defining an anchor point on both bodies and the non-zero length of the distance joint. The definition uses local anchor points so that the initial configuration can violate the constraint slightly. This helps when saving and loading a game.
5949 WARNING:
5950 Do not use a zero or short length.
5951 """
5952 _Box2D.b2DistanceJointDef_swiginit(self,_Box2D.new_b2DistanceJointDef())
5954 """
5955 Initialize(self, b2Body body1, b2Body body2, b2Vec2 anchor1, b2Vec2 anchor2)
5956
5957 Initialize the bodies, anchors, and length using the world anchors.
5958 """
5959 return _Box2D.b2DistanceJointDef_Initialize(self, *args)
5960
5961 localAnchor1 = _swig_property(_Box2D.b2DistanceJointDef_localAnchor1_get, _Box2D.b2DistanceJointDef_localAnchor1_set)
5962 localAnchor2 = _swig_property(_Box2D.b2DistanceJointDef_localAnchor2_get, _Box2D.b2DistanceJointDef_localAnchor2_set)
5963 length = _swig_property(_Box2D.b2DistanceJointDef_length_get, _Box2D.b2DistanceJointDef_length_set)
5964 frequencyHz = _swig_property(_Box2D.b2DistanceJointDef_frequencyHz_get, _Box2D.b2DistanceJointDef_frequencyHz_set)
5965 dampingRatio = _swig_property(_Box2D.b2DistanceJointDef_dampingRatio_get, _Box2D.b2DistanceJointDef_dampingRatio_set)
5967 return """b2DistanceJointDef(
5968 body1 = %s,
5969 body2 = %s,
5970 collideConnected = %s,
5971 dampingRatio = %s,
5972 frequencyHz = %s,
5973 length = %s,
5974 localAnchor1 = %s,
5975 localAnchor2 = %s,
5976 type = %s,
5977 userData = %s)"""% tuple(str(a) for a in\
5978 (self.body1,self.body2,self.collideConnected,self.dampingRatio,self.frequencyHz,self.length,self.localAnchor1,self.localAnchor2,self.type,self.userData))
5979
5980 __getstate__=_generic_getstate
5981 __setstate__=_generic_setstate
5982
5983 __swig_destroy__ = _Box2D.delete_b2DistanceJointDef
5984 b2DistanceJointDef.Initialize = new_instancemethod(_Box2D.b2DistanceJointDef_Initialize,None,b2DistanceJointDef)
5985 b2DistanceJointDef_swigregister = _Box2D.b2DistanceJointDef_swigregister
5986 b2DistanceJointDef_swigregister(b2DistanceJointDef)
5987
5989 """A distance joint constrains two points on two bodies to remain at a fixed distance from each other. You can view this as a massless, rigid rod."""
5990 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
5991 __repr__ = _swig_repr
5993 """
5994 __init__(self, b2DistanceJointDef data) -> b2DistanceJoint
5995
5996 A distance joint constrains two points on two bodies to remain at a fixed distance from each other. You can view this as a massless, rigid rod.
5997 """
5998 _Box2D.b2DistanceJoint_swiginit(self,_Box2D.new_b2DistanceJoint(*args))
6000 """InitVelocityConstraints(self, b2TimeStep step)"""
6001 return _Box2D.b2DistanceJoint_InitVelocityConstraints(self, *args)
6002
6004 """SolveVelocityConstraints(self, b2TimeStep step)"""
6005 return _Box2D.b2DistanceJoint_SolveVelocityConstraints(self, *args)
6006
6008 """SolvePositionConstraints(self, float32 baumgarte) -> bool"""
6009 return _Box2D.b2DistanceJoint_SolvePositionConstraints(self, *args)
6010
6011 localAnchor1 = _swig_property(_Box2D.b2DistanceJoint_localAnchor1_get, _Box2D.b2DistanceJoint_localAnchor1_set)
6012 localAnchor2 = _swig_property(_Box2D.b2DistanceJoint_localAnchor2_get, _Box2D.b2DistanceJoint_localAnchor2_set)
6013 u = _swig_property(_Box2D.b2DistanceJoint_u_get, _Box2D.b2DistanceJoint_u_set)
6014 frequencyHz = _swig_property(_Box2D.b2DistanceJoint_frequencyHz_get, _Box2D.b2DistanceJoint_frequencyHz_set)
6015 dampingRatio = _swig_property(_Box2D.b2DistanceJoint_dampingRatio_get, _Box2D.b2DistanceJoint_dampingRatio_set)
6016 gamma = _swig_property(_Box2D.b2DistanceJoint_gamma_get, _Box2D.b2DistanceJoint_gamma_set)
6017 bias = _swig_property(_Box2D.b2DistanceJoint_bias_get, _Box2D.b2DistanceJoint_bias_set)
6018 impulse = _swig_property(_Box2D.b2DistanceJoint_impulse_get, _Box2D.b2DistanceJoint_impulse_set)
6019 mass = _swig_property(_Box2D.b2DistanceJoint_mass_get, _Box2D.b2DistanceJoint_mass_set)
6020 length = _swig_property(_Box2D.b2DistanceJoint_length_get, _Box2D.b2DistanceJoint_length_set)
6022 return """b2DistanceJoint(
6023 bias = %s,
6024 body1 = %s,
6025 body2 = %s,
6026 collideConnected = %s,
6027 dampingRatio = %s,
6028 frequencyHz = %s,
6029 gamma = %s,
6030 impulse = %s,
6031 length = %s,
6032 localAnchor1 = %s,
6033 localAnchor2 = %s,
6034 mass = %s,
6035 type = %s,
6036 u = %s,
6037 userData = %s,
6038 GetAnchor1() = %s,
6039 GetAnchor2() = %s)"""% tuple(str(a) for a in\
6040 (self.bias,self.body1,self.body2,self.collideConnected,self.dampingRatio,self.frequencyHz,self.gamma,self.impulse,self.length,self.localAnchor1,self.localAnchor2,self.mass,self.type,self.u,self.userData,self.GetAnchor1(),self.GetAnchor2()))
6041
6042 __getstate__=_pickle_get_joint
6043 __setstate__=_pickle_factory_set
6044 _pickle_finalize=_pickle_finalize_joint
6045
6046 __swig_destroy__ = _Box2D.delete_b2DistanceJoint
6047 b2DistanceJoint.InitVelocityConstraints = new_instancemethod(_Box2D.b2DistanceJoint_InitVelocityConstraints,None,b2DistanceJoint)
6048 b2DistanceJoint.SolveVelocityConstraints = new_instancemethod(_Box2D.b2DistanceJoint_SolveVelocityConstraints,None,b2DistanceJoint)
6049 b2DistanceJoint.SolvePositionConstraints = new_instancemethod(_Box2D.b2DistanceJoint_SolvePositionConstraints,None,b2DistanceJoint)
6050 b2DistanceJoint_swigregister = _Box2D.b2DistanceJoint_swigregister
6051 b2DistanceJoint_swigregister(b2DistanceJoint)
6052
6054 """Gear joint definition. This definition requires two existing revolute or prismatic joints (any combination will work). The provided joints must attach a dynamic body to a static body."""
6055 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
6056 __repr__ = _swig_repr
6058 """
6059 __init__(self) -> b2GearJointDef
6060
6061 Gear joint definition. This definition requires two existing revolute or prismatic joints (any combination will work). The provided joints must attach a dynamic body to a static body.
6062 """
6063 _Box2D.b2GearJointDef_swiginit(self,_Box2D.new_b2GearJointDef())
6064 joint1 = _swig_property(_Box2D.b2GearJointDef_joint1_get, _Box2D.b2GearJointDef_joint1_set)
6065 joint2 = _swig_property(_Box2D.b2GearJointDef_joint2_get, _Box2D.b2GearJointDef_joint2_set)
6066 ratio = _swig_property(_Box2D.b2GearJointDef_ratio_get, _Box2D.b2GearJointDef_ratio_set)
6068 return """b2GearJointDef(
6069 body1 = %s,
6070 body2 = %s,
6071 collideConnected = %s,
6072 joint1 = %s,
6073 joint2 = %s,
6074 ratio = %s,
6075 type = %s,
6076 userData = %s)"""% tuple(str(a) for a in\
6077 (self.body1,self.body2,self.collideConnected,self.joint1,self.joint2,self.ratio,self.type,self.userData))
6078
6079 __getstate__=_generic_getstate
6080 __setstate__=_generic_setstate
6081
6082 __swig_destroy__ = _Box2D.delete_b2GearJointDef
6083 b2GearJointDef_swigregister = _Box2D.b2GearJointDef_swigregister
6084 b2GearJointDef_swigregister(b2GearJointDef)
6085
6087 """
6088 A gear joint is used to connect two joints together. Either joint can be a revolute or prismatic joint. You specify a gear ratio to bind the motions together: coordinate1 + ratio * coordinate2 = constant The ratio can be negative or positive. If one joint is a revolute joint and the other joint is a prismatic joint, then the ratio will have units of length or units of 1/length.
6089 WARNING:
6090 The revolute and prismatic joints must be attached to fixed bodies (which must be body1 on those joints).
6091 """
6092 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
6093 __repr__ = _swig_repr
6095 """
6096 GetRatio(self) -> float32
6097
6098 Get the gear ratio.
6099 """
6100 return _Box2D.b2GearJoint_GetRatio(self)
6101
6103 """
6104 __init__(self, b2GearJointDef data) -> b2GearJoint
6105
6106 A gear joint is used to connect two joints together. Either joint can be a revolute or prismatic joint. You specify a gear ratio to bind the motions together: coordinate1 + ratio * coordinate2 = constant The ratio can be negative or positive. If one joint is a revolute joint and the other joint is a prismatic joint, then the ratio will have units of length or units of 1/length.
6107 WARNING:
6108 The revolute and prismatic joints must be attached to fixed bodies (which must be body1 on those joints).
6109 """
6110 _Box2D.b2GearJoint_swiginit(self,_Box2D.new_b2GearJoint(*args))
6112 """InitVelocityConstraints(self, b2TimeStep step)"""
6113 return _Box2D.b2GearJoint_InitVelocityConstraints(self, *args)
6114
6116 """SolveVelocityConstraints(self, b2TimeStep step)"""
6117 return _Box2D.b2GearJoint_SolveVelocityConstraints(self, *args)
6118
6120 """SolvePositionConstraints(self, float32 baumgarte) -> bool"""
6121 return _Box2D.b2GearJoint_SolvePositionConstraints(self, *args)
6122
6123 ground1 = _swig_property(_Box2D.b2GearJoint_ground1_get, _Box2D.b2GearJoint_ground1_set)
6124 ground2 = _swig_property(_Box2D.b2GearJoint_ground2_get, _Box2D.b2GearJoint_ground2_set)
6125 revolute1 = _swig_property(_Box2D.b2GearJoint_revolute1_get, _Box2D.b2GearJoint_revolute1_set)
6126 prismatic1 = _swig_property(_Box2D.b2GearJoint_prismatic1_get, _Box2D.b2GearJoint_prismatic1_set)
6127 revolute2 = _swig_property(_Box2D.b2GearJoint_revolute2_get, _Box2D.b2GearJoint_revolute2_set)
6128 prismatic2 = _swig_property(_Box2D.b2GearJoint_prismatic2_get, _Box2D.b2GearJoint_prismatic2_set)
6129 groundAnchor1 = _swig_property(_Box2D.b2GearJoint_groundAnchor1_get, _Box2D.b2GearJoint_groundAnchor1_set)
6130 groundAnchor2 = _swig_property(_Box2D.b2GearJoint_groundAnchor2_get, _Box2D.b2GearJoint_groundAnchor2_set)
6131 localAnchor1 = _swig_property(_Box2D.b2GearJoint_localAnchor1_get, _Box2D.b2GearJoint_localAnchor1_set)
6132 localAnchor2 = _swig_property(_Box2D.b2GearJoint_localAnchor2_get, _Box2D.b2GearJoint_localAnchor2_set)
6133 J = _swig_property(_Box2D.b2GearJoint_J_get, _Box2D.b2GearJoint_J_set)
6134 constant = _swig_property(_Box2D.b2GearJoint_constant_get, _Box2D.b2GearJoint_constant_set)
6135 ratio = _swig_property(_Box2D.b2GearJoint_ratio_get, _Box2D.b2GearJoint_ratio_set)
6136 mass = _swig_property(_Box2D.b2GearJoint_mass_get, _Box2D.b2GearJoint_mass_set)
6137 impulse = _swig_property(_Box2D.b2GearJoint_impulse_get, _Box2D.b2GearJoint_impulse_set)
6139 return """b2GearJoint(
6140 J = %s,
6141 body1 = %s,
6142 body2 = %s,
6143 collideConnected = %s,
6144 constant = %s,
6145 ground1 = %s,
6146 ground2 = %s,
6147 groundAnchor1 = %s,
6148 groundAnchor2 = %s,
6149 impulse = %s,
6150 joint1 = %s,
6151 joint2 = %s,
6152 localAnchor1 = %s,
6153 localAnchor2 = %s,
6154 mass = %s,
6155 prismatic1 = %s,
6156 prismatic2 = %s,
6157 ratio = %s,
6158 revolute1 = %s,
6159 revolute2 = %s,
6160 type = %s,
6161 userData = %s,
6162 GetAnchor1() = %s,
6163 GetAnchor2() = %s)"""% tuple(str(a) for a in\
6164 (self.J,self.body1,self.body2,self.collideConnected,self.constant,self.ground1,self.ground2,self.groundAnchor1,self.groundAnchor2,self.impulse,self.joint1,self.joint2,self.localAnchor1,self.localAnchor2,self.mass,self.prismatic1,self.prismatic2,self.ratio,self.revolute1,self.revolute2,self.type,self.userData,self.GetAnchor1(),self.GetAnchor2()))
6165
6166 __getstate__=_pickle_get_joint
6167 __setstate__=_pickle_factory_set
6168 _pickle_finalize=_pickle_finalize_joint
6169
6170 joint1 = property(lambda self: (self.revolute1 and self.revolute1) or self.prismatic1, None)
6171 joint2 = property(lambda self: (self.revolute2 and self.revolute2) or self.prismatic2, None)
6172
6173 __swig_destroy__ = _Box2D.delete_b2GearJoint
6174 b2GearJoint.GetRatio = new_instancemethod(_Box2D.b2GearJoint_GetRatio,None,b2GearJoint)
6175 b2GearJoint.InitVelocityConstraints = new_instancemethod(_Box2D.b2GearJoint_InitVelocityConstraints,None,b2GearJoint)
6176 b2GearJoint.SolveVelocityConstraints = new_instancemethod(_Box2D.b2GearJoint_SolveVelocityConstraints,None,b2GearJoint)
6177 b2GearJoint.SolvePositionConstraints = new_instancemethod(_Box2D.b2GearJoint_SolvePositionConstraints,None,b2GearJoint)
6178 b2GearJoint_swigregister = _Box2D.b2GearJoint_swigregister
6179 b2GearJoint_swigregister(b2GearJoint)
6180
6182 """Line joint definition. This requires defining a line of motion using an axis and an anchor point. The definition uses local anchor points and a local axis so that the initial configuration can violate the constraint slightly. The joint translation is zero when the local anchor points coincide in world space. Using local anchors and a local axis helps when saving and loading a game."""
6183 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
6184 __repr__ = _swig_repr
6186 """
6187 __init__(self) -> b2LineJointDef
6188
6189 Line joint definition. This requires defining a line of motion using an axis and an anchor point. The definition uses local anchor points and a local axis so that the initial configuration can violate the constraint slightly. The joint translation is zero when the local anchor points coincide in world space. Using local anchors and a local axis helps when saving and loading a game.
6190 """
6191 _Box2D.b2LineJointDef_swiginit(self,_Box2D.new_b2LineJointDef())
6193 """
6194 Initialize(self, b2Body body1, b2Body body2, b2Vec2 anchor, b2Vec2 axis)
6195
6196 Initialize the bodies, anchors, axis, and reference angle using the world anchor and world axis.
6197 """
6198 return _Box2D.b2LineJointDef_Initialize(self, *args)
6199
6200 localAnchor1 = _swig_property(_Box2D.b2LineJointDef_localAnchor1_get, _Box2D.b2LineJointDef_localAnchor1_set)
6201 localAnchor2 = _swig_property(_Box2D.b2LineJointDef_localAnchor2_get, _Box2D.b2LineJointDef_localAnchor2_set)
6202 localAxis1 = _swig_property(_Box2D.b2LineJointDef_localAxis1_get, _Box2D.b2LineJointDef_localAxis1_set)
6203 enableLimit = _swig_property(_Box2D.b2LineJointDef_enableLimit_get, _Box2D.b2LineJointDef_enableLimit_set)
6204 lowerTranslation = _swig_property(_Box2D.b2LineJointDef_lowerTranslation_get, _Box2D.b2LineJointDef_lowerTranslation_set)
6205 upperTranslation = _swig_property(_Box2D.b2LineJointDef_upperTranslation_get, _Box2D.b2LineJointDef_upperTranslation_set)
6206 enableMotor = _swig_property(_Box2D.b2LineJointDef_enableMotor_get, _Box2D.b2LineJointDef_enableMotor_set)
6207 maxMotorForce = _swig_property(_Box2D.b2LineJointDef_maxMotorForce_get, _Box2D.b2LineJointDef_maxMotorForce_set)
6208 motorSpeed = _swig_property(_Box2D.b2LineJointDef_motorSpeed_get, _Box2D.b2LineJointDef_motorSpeed_set)
6210 return """b2LineJointDef(
6211 body1 = %s,
6212 body2 = %s,
6213 collideConnected = %s,
6214 enableLimit = %s,
6215 enableMotor = %s,
6216 localAnchor1 = %s,
6217 localAnchor2 = %s,
6218 localAxis1 = %s,
6219 lowerTranslation = %s,
6220 maxMotorForce = %s,
6221 motorSpeed = %s,
6222 type = %s,
6223 upperTranslation = %s,
6224 userData = %s)"""% tuple(str(a) for a in\
6225 (self.body1,self.body2,self.collideConnected,self.enableLimit,self.enableMotor,self.localAnchor1,self.localAnchor2,self.localAxis1,self.lowerTranslation,self.maxMotorForce,self.motorSpeed,self.type,self.upperTranslation,self.userData))
6226
6227 __getstate__=_generic_getstate
6228 __setstate__=_generic_setstate
6229
6230 __swig_destroy__ = _Box2D.delete_b2LineJointDef
6231 b2LineJointDef.Initialize = new_instancemethod(_Box2D.b2LineJointDef_Initialize,None,b2LineJointDef)
6232 b2LineJointDef_swigregister = _Box2D.b2LineJointDef_swigregister
6233 b2LineJointDef_swigregister(b2LineJointDef)
6234
6236 """A line joint. This joint provides one degree of freedom: translation along an axis fixed in body1. You can use a joint limit to restrict the range of motion and a joint motor to drive the motion or to model joint friction."""
6237 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
6238 __repr__ = _swig_repr
6240 """
6241 GetJointTranslation(self) -> float32
6242
6243 Get the current joint translation, usually in meters.
6244 """
6245 return _Box2D.b2LineJoint_GetJointTranslation(self)
6246
6248 """
6249 GetJointSpeed(self) -> float32
6250
6251 Get the current joint translation speed, usually in meters per second.
6252 """
6253 return _Box2D.b2LineJoint_GetJointSpeed(self)
6254
6256 """
6257 IsLimitEnabled(self) -> bool
6258
6259 Is the joint limit enabled?
6260 """
6261 return _Box2D.b2LineJoint_IsLimitEnabled(self)
6262
6264 """
6265 EnableLimit(self, bool flag)
6266
6267 Enable/disable the joint limit.
6268 """
6269 return _Box2D.b2LineJoint_EnableLimit(self, *args)
6270
6272 """
6273 GetLowerLimit(self) -> float32
6274
6275 Get the lower joint limit, usually in meters.
6276 """
6277 return _Box2D.b2LineJoint_GetLowerLimit(self)
6278
6280 """
6281 GetUpperLimit(self) -> float32
6282
6283 Get the upper joint limit, usually in meters.
6284 """
6285 return _Box2D.b2LineJoint_GetUpperLimit(self)
6286
6288 """
6289 SetLimits(self, float32 lower, float32 upper)
6290
6291 Set the joint limits, usually in meters.
6292 """
6293 return _Box2D.b2LineJoint_SetLimits(self, *args)
6294
6296 """
6297 IsMotorEnabled(self) -> bool
6298
6299 Is the joint motor enabled?
6300 """
6301 return _Box2D.b2LineJoint_IsMotorEnabled(self)
6302
6304 """
6305 EnableMotor(self, bool flag)
6306
6307 Enable/disable the joint motor.
6308 """
6309 return _Box2D.b2LineJoint_EnableMotor(self, *args)
6310
6312 """
6313 SetMotorSpeed(self, float32 speed)
6314
6315 Set the motor speed, usually in meters per second.
6316 """
6317 return _Box2D.b2LineJoint_SetMotorSpeed(self, *args)
6318
6320 """
6321 GetMotorSpeed(self) -> float32
6322
6323 Get the motor speed, usually in meters per second.
6324 """
6325 return _Box2D.b2LineJoint_GetMotorSpeed(self)
6326
6328 """
6329 SetMaxMotorForce(self, float32 force)
6330
6331 Set the maximum motor force, usually in N.
6332 """
6333 return _Box2D.b2LineJoint_SetMaxMotorForce(self, *args)
6334
6336 """
6337 GetMotorForce(self) -> float32
6338
6339 Get the current motor force, usually in N.
6340 """
6341 return _Box2D.b2LineJoint_GetMotorForce(self)
6342
6344 """
6345 __init__(self, b2LineJointDef _def) -> b2LineJoint
6346
6347 A line joint. This joint provides one degree of freedom: translation along an axis fixed in body1. You can use a joint limit to restrict the range of motion and a joint motor to drive the motion or to model joint friction.
6348 """
6349 _Box2D.b2LineJoint_swiginit(self,_Box2D.new_b2LineJoint(*args))
6351 """InitVelocityConstraints(self, b2TimeStep step)"""
6352 return _Box2D.b2LineJoint_InitVelocityConstraints(self, *args)
6353
6355 """SolveVelocityConstraints(self, b2TimeStep step)"""
6356 return _Box2D.b2LineJoint_SolveVelocityConstraints(self, *args)
6357
6359 """SolvePositionConstraints(self, float32 baumgarte) -> bool"""
6360 return _Box2D.b2LineJoint_SolvePositionConstraints(self, *args)
6361
6362 localAnchor1 = _swig_property(_Box2D.b2LineJoint_localAnchor1_get, _Box2D.b2LineJoint_localAnchor1_set)
6363 localAnchor2 = _swig_property(_Box2D.b2LineJoint_localAnchor2_get, _Box2D.b2LineJoint_localAnchor2_set)
6364 localXAxis1 = _swig_property(_Box2D.b2LineJoint_localXAxis1_get, _Box2D.b2LineJoint_localXAxis1_set)
6365 localYAxis1 = _swig_property(_Box2D.b2LineJoint_localYAxis1_get, _Box2D.b2LineJoint_localYAxis1_set)
6366 axis = _swig_property(_Box2D.b2LineJoint_axis_get, _Box2D.b2LineJoint_axis_set)
6367 perp = _swig_property(_Box2D.b2LineJoint_perp_get, _Box2D.b2LineJoint_perp_set)
6368 s1 = _swig_property(_Box2D.b2LineJoint_s1_get, _Box2D.b2LineJoint_s1_set)
6369 s2 = _swig_property(_Box2D.b2LineJoint_s2_get, _Box2D.b2LineJoint_s2_set)
6370 a1 = _swig_property(_Box2D.b2LineJoint_a1_get, _Box2D.b2LineJoint_a1_set)
6371 a2 = _swig_property(_Box2D.b2LineJoint_a2_get, _Box2D.b2LineJoint_a2_set)
6372 K = _swig_property(_Box2D.b2LineJoint_K_get, _Box2D.b2LineJoint_K_set)
6373 impulse = _swig_property(_Box2D.b2LineJoint_impulse_get, _Box2D.b2LineJoint_impulse_set)
6374 motorMass = _swig_property(_Box2D.b2LineJoint_motorMass_get, _Box2D.b2LineJoint_motorMass_set)
6375 motorImpulse = _swig_property(_Box2D.b2LineJoint_motorImpulse_get, _Box2D.b2LineJoint_motorImpulse_set)
6376 lowerTranslation = _swig_property(_Box2D.b2LineJoint_lowerTranslation_get, _Box2D.b2LineJoint_lowerTranslation_set)
6377 upperTranslation = _swig_property(_Box2D.b2LineJoint_upperTranslation_get, _Box2D.b2LineJoint_upperTranslation_set)
6378 maxMotorForce = _swig_property(_Box2D.b2LineJoint_maxMotorForce_get, _Box2D.b2LineJoint_maxMotorForce_set)
6379 motorSpeed = _swig_property(_Box2D.b2LineJoint_motorSpeed_get, _Box2D.b2LineJoint_motorSpeed_set)
6380 enableLimit = _swig_property(_Box2D.b2LineJoint_enableLimit_get, _Box2D.b2LineJoint_enableLimit_set)
6381 enableMotor = _swig_property(_Box2D.b2LineJoint_enableMotor_get, _Box2D.b2LineJoint_enableMotor_set)
6382 limitState = _swig_property(_Box2D.b2LineJoint_limitState_get, _Box2D.b2LineJoint_limitState_set)
6384 return """b2LineJoint(
6385 K = %s,
6386 a1 = %s,
6387 a2 = %s,
6388 axis = %s,
6389 body1 = %s,
6390 body2 = %s,
6391 collideConnected = %s,
6392 enableLimit = %s,
6393 enableMotor = %s,
6394 impulse = %s,
6395 limitState = %s,
6396 localAnchor1 = %s,
6397 localAnchor2 = %s,
6398 localXAxis1 = %s,
6399 localYAxis1 = %s,
6400 lowerTranslation = %s,
6401 maxMotorForce = %s,
6402 motorImpulse = %s,
6403 motorMass = %s,
6404 motorSpeed = %s,
6405 perp = %s,
6406 s1 = %s,
6407 s2 = %s,
6408 type = %s,
6409 upperTranslation = %s,
6410 userData = %s,
6411 GetAnchor1() = %s,
6412 GetAnchor2() = %s,
6413 GetJointSpeed() = %s,
6414 GetJointTranslation() = %s,
6415 GetLowerLimit() = %s,
6416 GetMotorForce() = %s,
6417 GetUpperLimit() = %s,
6418 IsLimitEnabled() = %s,
6419 IsMotorEnabled() = %s)"""% tuple(str(a) for a in\
6420 (self.K,self.a1,self.a2,self.axis,self.body1,self.body2,self.collideConnected,self.enableLimit,self.enableMotor,self.impulse,self.limitState,self.localAnchor1,self.localAnchor2,self.localXAxis1,self.localYAxis1,self.lowerTranslation,self.maxMotorForce,self.motorImpulse,self.motorMass,self.motorSpeed,self.perp,self.s1,self.s2,self.type,self.upperTranslation,self.userData,self.GetAnchor1(),self.GetAnchor2(),self.GetJointSpeed(),self.GetJointTranslation(),self.GetLowerLimit(),self.GetMotorForce(),self.GetUpperLimit(),self.IsLimitEnabled(),self.IsMotorEnabled()))
6421
6422 __getstate__=_pickle_get_joint
6423 __setstate__=_pickle_factory_set
6424 _pickle_finalize=_pickle_finalize_joint
6425
6426 __swig_destroy__ = _Box2D.delete_b2LineJoint
6427 b2LineJoint.GetJointTranslation = new_instancemethod(_Box2D.b2LineJoint_GetJointTranslation,None,b2LineJoint)
6428 b2LineJoint.GetJointSpeed = new_instancemethod(_Box2D.b2LineJoint_GetJointSpeed,None,b2LineJoint)
6429 b2LineJoint.IsLimitEnabled = new_instancemethod(_Box2D.b2LineJoint_IsLimitEnabled,None,b2LineJoint)
6430 b2LineJoint.EnableLimit = new_instancemethod(_Box2D.b2LineJoint_EnableLimit,None,b2LineJoint)
6431 b2LineJoint.GetLowerLimit = new_instancemethod(_Box2D.b2LineJoint_GetLowerLimit,None,b2LineJoint)
6432 b2LineJoint.GetUpperLimit = new_instancemethod(_Box2D.b2LineJoint_GetUpperLimit,None,b2LineJoint)
6433 b2LineJoint.SetLimits = new_instancemethod(_Box2D.b2LineJoint_SetLimits,None,b2LineJoint)
6434 b2LineJoint.IsMotorEnabled = new_instancemethod(_Box2D.b2LineJoint_IsMotorEnabled,None,b2LineJoint)
6435 b2LineJoint.EnableMotor = new_instancemethod(_Box2D.b2LineJoint_EnableMotor,None,b2LineJoint)
6436 b2LineJoint.SetMotorSpeed = new_instancemethod(_Box2D.b2LineJoint_SetMotorSpeed,None,b2LineJoint)
6437 b2LineJoint.GetMotorSpeed = new_instancemethod(_Box2D.b2LineJoint_GetMotorSpeed,None,b2LineJoint)
6438 b2LineJoint.SetMaxMotorForce = new_instancemethod(_Box2D.b2LineJoint_SetMaxMotorForce,None,b2LineJoint)
6439 b2LineJoint.GetMotorForce = new_instancemethod(_Box2D.b2LineJoint_GetMotorForce,None,b2LineJoint)
6440 b2LineJoint.InitVelocityConstraints = new_instancemethod(_Box2D.b2LineJoint_InitVelocityConstraints,None,b2LineJoint)
6441 b2LineJoint.SolveVelocityConstraints = new_instancemethod(_Box2D.b2LineJoint_SolveVelocityConstraints,None,b2LineJoint)
6442 b2LineJoint.SolvePositionConstraints = new_instancemethod(_Box2D.b2LineJoint_SolvePositionConstraints,None,b2LineJoint)
6443 b2LineJoint_swigregister = _Box2D.b2LineJoint_swigregister
6444 b2LineJoint_swigregister(b2LineJoint)
6445
6447 """Mouse joint definition. This requires a world target point, tuning parameters, and the time step."""
6448 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
6449 __repr__ = _swig_repr
6451 """
6452 __init__(self) -> b2MouseJointDef
6453
6454 Mouse joint definition. This requires a world target point, tuning parameters, and the time step.
6455 """
6456 _Box2D.b2MouseJointDef_swiginit(self,_Box2D.new_b2MouseJointDef())
6457 target = _swig_property(_Box2D.b2MouseJointDef_target_get, _Box2D.b2MouseJointDef_target_set)
6458 maxForce = _swig_property(_Box2D.b2MouseJointDef_maxForce_get, _Box2D.b2MouseJointDef_maxForce_set)
6459 frequencyHz = _swig_property(_Box2D.b2MouseJointDef_frequencyHz_get, _Box2D.b2MouseJointDef_frequencyHz_set)
6460 dampingRatio = _swig_property(_Box2D.b2MouseJointDef_dampingRatio_get, _Box2D.b2MouseJointDef_dampingRatio_set)
6462 return """b2MouseJointDef(
6463 body1 = %s,
6464 body2 = %s,
6465 collideConnected = %s,
6466 dampingRatio = %s,
6467 frequencyHz = %s,
6468 maxForce = %s,
6469 target = %s,
6470 type = %s,
6471 userData = %s)"""% tuple(str(a) for a in\
6472 (self.body1,self.body2,self.collideConnected,self.dampingRatio,self.frequencyHz,self.maxForce,self.target,self.type,self.userData))
6473
6474 __getstate__=_generic_getstate
6475 __setstate__=_generic_setstate
6476
6477 __swig_destroy__ = _Box2D.delete_b2MouseJointDef
6478 b2MouseJointDef_swigregister = _Box2D.b2MouseJointDef_swigregister
6479 b2MouseJointDef_swigregister(b2MouseJointDef)
6480
6482 """A mouse joint is used to make a point on a body track a specified world point. This a soft constraint with a maximum force. This allows the constraint to stretch and without applying huge forces."""
6483 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
6484 __repr__ = _swig_repr
6486 """
6487 SetTarget(self, b2Vec2 target)
6488
6489 Use this to update the target point.
6490 """
6491 return _Box2D.b2MouseJoint_SetTarget(self, *args)
6492
6494 """
6495 __init__(self, b2MouseJointDef _def) -> b2MouseJoint
6496
6497 A mouse joint is used to make a point on a body track a specified world point. This a soft constraint with a maximum force. This allows the constraint to stretch and without applying huge forces.
6498 """
6499 _Box2D.b2MouseJoint_swiginit(self,_Box2D.new_b2MouseJoint(*args))
6501 """InitVelocityConstraints(self, b2TimeStep step)"""
6502 return _Box2D.b2MouseJoint_InitVelocityConstraints(self, *args)
6503
6505 """SolveVelocityConstraints(self, b2TimeStep step)"""
6506 return _Box2D.b2MouseJoint_SolveVelocityConstraints(self, *args)
6507
6509 """SolvePositionConstraints(self, float32 baumgarte) -> bool"""
6510 return _Box2D.b2MouseJoint_SolvePositionConstraints(self, *args)
6511
6512 localAnchor = _swig_property(_Box2D.b2MouseJoint_localAnchor_get, _Box2D.b2MouseJoint_localAnchor_set)
6513 target = _swig_property(_Box2D.b2MouseJoint_target_get, _Box2D.b2MouseJoint_target_set)
6514 impulse = _swig_property(_Box2D.b2MouseJoint_impulse_get, _Box2D.b2MouseJoint_impulse_set)
6515 mass = _swig_property(_Box2D.b2MouseJoint_mass_get, _Box2D.b2MouseJoint_mass_set)
6516 C = _swig_property(_Box2D.b2MouseJoint_C_get, _Box2D.b2MouseJoint_C_set)
6517 maxForce = _swig_property(_Box2D.b2MouseJoint_maxForce_get, _Box2D.b2MouseJoint_maxForce_set)
6518 frequencyHz = _swig_property(_Box2D.b2MouseJoint_frequencyHz_get, _Box2D.b2MouseJoint_frequencyHz_set)
6519 dampingRatio = _swig_property(_Box2D.b2MouseJoint_dampingRatio_get, _Box2D.b2MouseJoint_dampingRatio_set)
6520 beta = _swig_property(_Box2D.b2MouseJoint_beta_get, _Box2D.b2MouseJoint_beta_set)
6521 gamma = _swig_property(_Box2D.b2MouseJoint_gamma_get, _Box2D.b2MouseJoint_gamma_set)
6523 return """b2MouseJoint(
6524 C = %s,
6525 beta = %s,
6526 body1 = %s,
6527 body2 = %s,
6528 collideConnected = %s,
6529 dampingRatio = %s,
6530 frequencyHz = %s,
6531 gamma = %s,
6532 impulse = %s,
6533 localAnchor = %s,
6534 mass = %s,
6535 maxForce = %s,
6536 target = %s,
6537 type = %s,
6538 userData = %s,
6539 GetAnchor1() = %s,
6540 GetAnchor2() = %s)"""% tuple(str(a) for a in\
6541 (self.C,self.beta,self.body1,self.body2,self.collideConnected,self.dampingRatio,self.frequencyHz,self.gamma,self.impulse,self.localAnchor,self.mass,self.maxForce,self.target,self.type,self.userData,self.GetAnchor1(),self.GetAnchor2()))
6542
6543 __getstate__=_pickle_get_joint
6544 __setstate__=_pickle_factory_set
6545 _pickle_finalize=_pickle_finalize_joint
6546
6547 __swig_destroy__ = _Box2D.delete_b2MouseJoint
6548 b2MouseJoint.SetTarget = new_instancemethod(_Box2D.b2MouseJoint_SetTarget,None,b2MouseJoint)
6549 b2MouseJoint.InitVelocityConstraints = new_instancemethod(_Box2D.b2MouseJoint_InitVelocityConstraints,None,b2MouseJoint)
6550 b2MouseJoint.SolveVelocityConstraints = new_instancemethod(_Box2D.b2MouseJoint_SolveVelocityConstraints,None,b2MouseJoint)
6551 b2MouseJoint.SolvePositionConstraints = new_instancemethod(_Box2D.b2MouseJoint_SolvePositionConstraints,None,b2MouseJoint)
6552 b2MouseJoint_swigregister = _Box2D.b2MouseJoint_swigregister
6553 b2MouseJoint_swigregister(b2MouseJoint)
6554
6556 """Prismatic joint definition. This requires defining a line of motion using an axis and an anchor point. The definition uses local anchor points and a local axis so that the initial configuration can violate the constraint slightly. The joint translation is zero when the local anchor points coincide in world space. Using local anchors and a local axis helps when saving and loading a game."""
6557 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
6558 __repr__ = _swig_repr
6560 """
6561 __init__(self) -> b2PrismaticJointDef
6562
6563 Prismatic joint definition. This requires defining a line of motion using an axis and an anchor point. The definition uses local anchor points and a local axis so that the initial configuration can violate the constraint slightly. The joint translation is zero when the local anchor points coincide in world space. Using local anchors and a local axis helps when saving and loading a game.
6564 """
6565 _Box2D.b2PrismaticJointDef_swiginit(self,_Box2D.new_b2PrismaticJointDef())
6567 """
6568 Initialize(self, b2Body body1, b2Body body2, b2Vec2 anchor, b2Vec2 axis)
6569
6570 Initialize the bodies, anchors, axis, and reference angle using the world anchor and world axis.
6571 """
6572 return _Box2D.b2PrismaticJointDef_Initialize(self, *args)
6573
6574 localAnchor1 = _swig_property(_Box2D.b2PrismaticJointDef_localAnchor1_get, _Box2D.b2PrismaticJointDef_localAnchor1_set)
6575 localAnchor2 = _swig_property(_Box2D.b2PrismaticJointDef_localAnchor2_get, _Box2D.b2PrismaticJointDef_localAnchor2_set)
6576 localAxis1 = _swig_property(_Box2D.b2PrismaticJointDef_localAxis1_get, _Box2D.b2PrismaticJointDef_localAxis1_set)
6577 referenceAngle = _swig_property(_Box2D.b2PrismaticJointDef_referenceAngle_get, _Box2D.b2PrismaticJointDef_referenceAngle_set)
6578 enableLimit = _swig_property(_Box2D.b2PrismaticJointDef_enableLimit_get, _Box2D.b2PrismaticJointDef_enableLimit_set)
6579 lowerTranslation = _swig_property(_Box2D.b2PrismaticJointDef_lowerTranslation_get, _Box2D.b2PrismaticJointDef_lowerTranslation_set)
6580 upperTranslation = _swig_property(_Box2D.b2PrismaticJointDef_upperTranslation_get, _Box2D.b2PrismaticJointDef_upperTranslation_set)
6581 enableMotor = _swig_property(_Box2D.b2PrismaticJointDef_enableMotor_get, _Box2D.b2PrismaticJointDef_enableMotor_set)
6582 maxMotorForce = _swig_property(_Box2D.b2PrismaticJointDef_maxMotorForce_get, _Box2D.b2PrismaticJointDef_maxMotorForce_set)
6583 motorSpeed = _swig_property(_Box2D.b2PrismaticJointDef_motorSpeed_get, _Box2D.b2PrismaticJointDef_motorSpeed_set)
6585 return """b2PrismaticJointDef(
6586 body1 = %s,
6587 body2 = %s,
6588 collideConnected = %s,
6589 enableLimit = %s,
6590 enableMotor = %s,
6591 localAnchor1 = %s,
6592 localAnchor2 = %s,
6593 localAxis1 = %s,
6594 lowerTranslation = %s,
6595 maxMotorForce = %s,
6596 motorSpeed = %s,
6597 referenceAngle = %s,
6598 type = %s,
6599 upperTranslation = %s,
6600 userData = %s)"""% tuple(str(a) for a in\
6601 (self.body1,self.body2,self.collideConnected,self.enableLimit,self.enableMotor,self.localAnchor1,self.localAnchor2,self.localAxis1,self.lowerTranslation,self.maxMotorForce,self.motorSpeed,self.referenceAngle,self.type,self.upperTranslation,self.userData))
6602
6603 __getstate__=_generic_getstate
6604 __setstate__=_generic_setstate
6605
6606 __swig_destroy__ = _Box2D.delete_b2PrismaticJointDef
6607 b2PrismaticJointDef.Initialize = new_instancemethod(_Box2D.b2PrismaticJointDef_Initialize,None,b2PrismaticJointDef)
6608 b2PrismaticJointDef_swigregister = _Box2D.b2PrismaticJointDef_swigregister
6609 b2PrismaticJointDef_swigregister(b2PrismaticJointDef)
6610
6612 """A prismatic joint. This joint provides one degree of freedom: translation along an axis fixed in body1. Relative rotation is prevented. You can use a joint limit to restrict the range of motion and a joint motor to drive the motion or to model joint friction."""
6613 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
6614 __repr__ = _swig_repr
6616 """
6617 GetJointTranslation(self) -> float32
6618
6619 Get the current joint translation, usually in meters.
6620 """
6621 return _Box2D.b2PrismaticJoint_GetJointTranslation(self)
6622
6624 """
6625 GetJointSpeed(self) -> float32
6626
6627 Get the current joint translation speed, usually in meters per second.
6628 """
6629 return _Box2D.b2PrismaticJoint_GetJointSpeed(self)
6630
6632 """
6633 IsLimitEnabled(self) -> bool
6634
6635 Is the joint limit enabled?
6636 """
6637 return _Box2D.b2PrismaticJoint_IsLimitEnabled(self)
6638
6640 """
6641 EnableLimit(self, bool flag)
6642
6643 Enable/disable the joint limit.
6644 """
6645 return _Box2D.b2PrismaticJoint_EnableLimit(self, *args)
6646
6648 """
6649 GetLowerLimit(self) -> float32
6650
6651 Get the lower joint limit, usually in meters.
6652 """
6653 return _Box2D.b2PrismaticJoint_GetLowerLimit(self)
6654
6656 """
6657 GetUpperLimit(self) -> float32
6658
6659 Get the upper joint limit, usually in meters.
6660 """
6661 return _Box2D.b2PrismaticJoint_GetUpperLimit(self)
6662
6664 """
6665 SetLimits(self, float32 lower, float32 upper)
6666
6667 Set the joint limits, usually in meters.
6668 """
6669 return _Box2D.b2PrismaticJoint_SetLimits(self, *args)
6670
6672 """
6673 IsMotorEnabled(self) -> bool
6674
6675 Is the joint motor enabled?
6676 """
6677 return _Box2D.b2PrismaticJoint_IsMotorEnabled(self)
6678
6680 """
6681 EnableMotor(self, bool flag)
6682
6683 Enable/disable the joint motor.
6684 """
6685 return _Box2D.b2PrismaticJoint_EnableMotor(self, *args)
6686
6688 """
6689 SetMotorSpeed(self, float32 speed)
6690
6691 Set the motor speed, usually in meters per second.
6692 """
6693 return _Box2D.b2PrismaticJoint_SetMotorSpeed(self, *args)
6694
6696 """
6697 GetMotorSpeed(self) -> float32
6698
6699 Get the motor speed, usually in meters per second.
6700 """
6701 return _Box2D.b2PrismaticJoint_GetMotorSpeed(self)
6702
6704 """
6705 SetMaxMotorForce(self, float32 force)
6706
6707 Set the maximum motor force, usually in N.
6708 """
6709 return _Box2D.b2PrismaticJoint_SetMaxMotorForce(self, *args)
6710
6712 """
6713 GetMotorForce(self) -> float32
6714
6715 Get the current motor force, usually in N.
6716 """
6717 return _Box2D.b2PrismaticJoint_GetMotorForce(self)
6718
6720 """
6721 __init__(self, b2PrismaticJointDef _def) -> b2PrismaticJoint
6722
6723 A prismatic joint. This joint provides one degree of freedom: translation along an axis fixed in body1. Relative rotation is prevented. You can use a joint limit to restrict the range of motion and a joint motor to drive the motion or to model joint friction.
6724 """
6725 _Box2D.b2PrismaticJoint_swiginit(self,_Box2D.new_b2PrismaticJoint(*args))
6727 """InitVelocityConstraints(self, b2TimeStep step)"""
6728 return _Box2D.b2PrismaticJoint_InitVelocityConstraints(self, *args)
6729
6731 """SolveVelocityConstraints(self, b2TimeStep step)"""
6732 return _Box2D.b2PrismaticJoint_SolveVelocityConstraints(self, *args)
6733
6735 """SolvePositionConstraints(self, float32 baumgarte) -> bool"""
6736 return _Box2D.b2PrismaticJoint_SolvePositionConstraints(self, *args)
6737
6738 localAnchor1 = _swig_property(_Box2D.b2PrismaticJoint_localAnchor1_get, _Box2D.b2PrismaticJoint_localAnchor1_set)
6739 localAnchor2 = _swig_property(_Box2D.b2PrismaticJoint_localAnchor2_get, _Box2D.b2PrismaticJoint_localAnchor2_set)
6740 localXAxis1 = _swig_property(_Box2D.b2PrismaticJoint_localXAxis1_get, _Box2D.b2PrismaticJoint_localXAxis1_set)
6741 localYAxis1 = _swig_property(_Box2D.b2PrismaticJoint_localYAxis1_get, _Box2D.b2PrismaticJoint_localYAxis1_set)
6742 referenceAngle = _swig_property(_Box2D.b2PrismaticJoint_referenceAngle_get, _Box2D.b2PrismaticJoint_referenceAngle_set)
6743 axis = _swig_property(_Box2D.b2PrismaticJoint_axis_get, _Box2D.b2PrismaticJoint_axis_set)
6744 perp = _swig_property(_Box2D.b2PrismaticJoint_perp_get, _Box2D.b2PrismaticJoint_perp_set)
6745 s1 = _swig_property(_Box2D.b2PrismaticJoint_s1_get, _Box2D.b2PrismaticJoint_s1_set)
6746 s2 = _swig_property(_Box2D.b2PrismaticJoint_s2_get, _Box2D.b2PrismaticJoint_s2_set)
6747 a1 = _swig_property(_Box2D.b2PrismaticJoint_a1_get, _Box2D.b2PrismaticJoint_a1_set)
6748 a2 = _swig_property(_Box2D.b2PrismaticJoint_a2_get, _Box2D.b2PrismaticJoint_a2_set)
6749 K = _swig_property(_Box2D.b2PrismaticJoint_K_get, _Box2D.b2PrismaticJoint_K_set)
6750 impulse = _swig_property(_Box2D.b2PrismaticJoint_impulse_get, _Box2D.b2PrismaticJoint_impulse_set)
6751 motorMass = _swig_property(_Box2D.b2PrismaticJoint_motorMass_get, _Box2D.b2PrismaticJoint_motorMass_set)
6752 motorImpulse = _swig_property(_Box2D.b2PrismaticJoint_motorImpulse_get, _Box2D.b2PrismaticJoint_motorImpulse_set)
6753 lowerTranslation = _swig_property(_Box2D.b2PrismaticJoint_lowerTranslation_get, _Box2D.b2PrismaticJoint_lowerTranslation_set)
6754 upperTranslation = _swig_property(_Box2D.b2PrismaticJoint_upperTranslation_get, _Box2D.b2PrismaticJoint_upperTranslation_set)
6755 maxMotorForce = _swig_property(_Box2D.b2PrismaticJoint_maxMotorForce_get, _Box2D.b2PrismaticJoint_maxMotorForce_set)
6756 motorSpeed = _swig_property(_Box2D.b2PrismaticJoint_motorSpeed_get, _Box2D.b2PrismaticJoint_motorSpeed_set)
6757 enableLimit = _swig_property(_Box2D.b2PrismaticJoint_enableLimit_get, _Box2D.b2PrismaticJoint_enableLimit_set)
6758 enableMotor = _swig_property(_Box2D.b2PrismaticJoint_enableMotor_get, _Box2D.b2PrismaticJoint_enableMotor_set)
6759 limitState = _swig_property(_Box2D.b2PrismaticJoint_limitState_get, _Box2D.b2PrismaticJoint_limitState_set)
6761 return """b2PrismaticJoint(
6762 K = %s,
6763 a1 = %s,
6764 a2 = %s,
6765 axis = %s,
6766 body1 = %s,
6767 body2 = %s,
6768 collideConnected = %s,
6769 enableLimit = %s,
6770 enableMotor = %s,
6771 impulse = %s,
6772 limitState = %s,
6773 localAnchor1 = %s,
6774 localAnchor2 = %s,
6775 localXAxis1 = %s,
6776 localYAxis1 = %s,
6777 lowerTranslation = %s,
6778 maxMotorForce = %s,
6779 motorImpulse = %s,
6780 motorMass = %s,
6781 motorSpeed = %s,
6782 perp = %s,
6783 referenceAngle = %s,
6784 s1 = %s,
6785 s2 = %s,
6786 type = %s,
6787 upperTranslation = %s,
6788 userData = %s,
6789 GetAnchor1() = %s,
6790 GetAnchor2() = %s,
6791 GetJointSpeed() = %s,
6792 GetJointTranslation() = %s,
6793 GetLowerLimit() = %s,
6794 GetMotorForce() = %s,
6795 GetUpperLimit() = %s,
6796 IsLimitEnabled() = %s,
6797 IsMotorEnabled() = %s)"""% tuple(str(a) for a in\
6798 (self.K,self.a1,self.a2,self.axis,self.body1,self.body2,self.collideConnected,self.enableLimit,self.enableMotor,self.impulse,self.limitState,self.localAnchor1,self.localAnchor2,self.localXAxis1,self.localYAxis1,self.lowerTranslation,self.maxMotorForce,self.motorImpulse,self.motorMass,self.motorSpeed,self.perp,self.referenceAngle,self.s1,self.s2,self.type,self.upperTranslation,self.userData,self.GetAnchor1(),self.GetAnchor2(),self.GetJointSpeed(),self.GetJointTranslation(),self.GetLowerLimit(),self.GetMotorForce(),self.GetUpperLimit(),self.IsLimitEnabled(),self.IsMotorEnabled()))
6799
6800 __getstate__=_pickle_get_joint
6801 __setstate__=_pickle_factory_set
6802 _pickle_finalize=_pickle_finalize_joint
6803
6804 __swig_destroy__ = _Box2D.delete_b2PrismaticJoint
6805 b2PrismaticJoint.GetJointTranslation = new_instancemethod(_Box2D.b2PrismaticJoint_GetJointTranslation,None,b2PrismaticJoint)
6806 b2PrismaticJoint.GetJointSpeed = new_instancemethod(_Box2D.b2PrismaticJoint_GetJointSpeed,None,b2PrismaticJoint)
6807 b2PrismaticJoint.IsLimitEnabled = new_instancemethod(_Box2D.b2PrismaticJoint_IsLimitEnabled,None,b2PrismaticJoint)
6808 b2PrismaticJoint.EnableLimit = new_instancemethod(_Box2D.b2PrismaticJoint_EnableLimit,None,b2PrismaticJoint)
6809 b2PrismaticJoint.GetLowerLimit = new_instancemethod(_Box2D.b2PrismaticJoint_GetLowerLimit,None,b2PrismaticJoint)
6810 b2PrismaticJoint.GetUpperLimit = new_instancemethod(_Box2D.b2PrismaticJoint_GetUpperLimit,None,b2PrismaticJoint)
6811 b2PrismaticJoint.SetLimits = new_instancemethod(_Box2D.b2PrismaticJoint_SetLimits,None,b2PrismaticJoint)
6812 b2PrismaticJoint.IsMotorEnabled = new_instancemethod(_Box2D.b2PrismaticJoint_IsMotorEnabled,None,b2PrismaticJoint)
6813 b2PrismaticJoint.EnableMotor = new_instancemethod(_Box2D.b2PrismaticJoint_EnableMotor,None,b2PrismaticJoint)
6814 b2PrismaticJoint.SetMotorSpeed = new_instancemethod(_Box2D.b2PrismaticJoint_SetMotorSpeed,None,b2PrismaticJoint)
6815 b2PrismaticJoint.GetMotorSpeed = new_instancemethod(_Box2D.b2PrismaticJoint_GetMotorSpeed,None,b2PrismaticJoint)
6816 b2PrismaticJoint.SetMaxMotorForce = new_instancemethod(_Box2D.b2PrismaticJoint_SetMaxMotorForce,None,b2PrismaticJoint)
6817 b2PrismaticJoint.GetMotorForce = new_instancemethod(_Box2D.b2PrismaticJoint_GetMotorForce,None,b2PrismaticJoint)
6818 b2PrismaticJoint.InitVelocityConstraints = new_instancemethod(_Box2D.b2PrismaticJoint_InitVelocityConstraints,None,b2PrismaticJoint)
6819 b2PrismaticJoint.SolveVelocityConstraints = new_instancemethod(_Box2D.b2PrismaticJoint_SolveVelocityConstraints,None,b2PrismaticJoint)
6820 b2PrismaticJoint.SolvePositionConstraints = new_instancemethod(_Box2D.b2PrismaticJoint_SolvePositionConstraints,None,b2PrismaticJoint)
6821 b2PrismaticJoint_swigregister = _Box2D.b2PrismaticJoint_swigregister
6822 b2PrismaticJoint_swigregister(b2PrismaticJoint)
6823
6825 """Pulley joint definition. This requires two ground anchors, two dynamic body anchor points, max lengths for each side, and a pulley ratio."""
6826 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
6827 __repr__ = _swig_repr
6829 """
6830 __init__(self) -> b2PulleyJointDef
6831
6832 Pulley joint definition. This requires two ground anchors, two dynamic body anchor points, max lengths for each side, and a pulley ratio.
6833 """
6834 _Box2D.b2PulleyJointDef_swiginit(self,_Box2D.new_b2PulleyJointDef())
6836 """
6837 Initialize(self, b2Body body1, b2Body body2, b2Vec2 groundAnchor1, b2Vec2 groundAnchor2,
6838 b2Vec2 anchor1, b2Vec2 anchor2,
6839 float32 ratio)
6840
6841 Initialize the bodies, anchors, lengths, max lengths, and ratio using the world anchors.
6842 """
6843 return _Box2D.b2PulleyJointDef_Initialize(self, *args)
6844
6845 groundAnchor1 = _swig_property(_Box2D.b2PulleyJointDef_groundAnchor1_get, _Box2D.b2PulleyJointDef_groundAnchor1_set)
6846 groundAnchor2 = _swig_property(_Box2D.b2PulleyJointDef_groundAnchor2_get, _Box2D.b2PulleyJointDef_groundAnchor2_set)
6847 localAnchor1 = _swig_property(_Box2D.b2PulleyJointDef_localAnchor1_get, _Box2D.b2PulleyJointDef_localAnchor1_set)
6848 localAnchor2 = _swig_property(_Box2D.b2PulleyJointDef_localAnchor2_get, _Box2D.b2PulleyJointDef_localAnchor2_set)
6849 length1 = _swig_property(_Box2D.b2PulleyJointDef_length1_get, _Box2D.b2PulleyJointDef_length1_set)
6850 maxLength1 = _swig_property(_Box2D.b2PulleyJointDef_maxLength1_get, _Box2D.b2PulleyJointDef_maxLength1_set)
6851 length2 = _swig_property(_Box2D.b2PulleyJointDef_length2_get, _Box2D.b2PulleyJointDef_length2_set)
6852 maxLength2 = _swig_property(_Box2D.b2PulleyJointDef_maxLength2_get, _Box2D.b2PulleyJointDef_maxLength2_set)
6853 ratio = _swig_property(_Box2D.b2PulleyJointDef_ratio_get, _Box2D.b2PulleyJointDef_ratio_set)
6855 return """b2PulleyJointDef(
6856 body1 = %s,
6857 body2 = %s,
6858 collideConnected = %s,
6859 groundAnchor1 = %s,
6860 groundAnchor2 = %s,
6861 length1 = %s,
6862 length2 = %s,
6863 localAnchor1 = %s,
6864 localAnchor2 = %s,
6865 maxLength1 = %s,
6866 maxLength2 = %s,
6867 ratio = %s,
6868 type = %s,
6869 userData = %s)"""% tuple(str(a) for a in\
6870 (self.body1,self.body2,self.collideConnected,self.groundAnchor1,self.groundAnchor2,self.length1,self.length2,self.localAnchor1,self.localAnchor2,self.maxLength1,self.maxLength2,self.ratio,self.type,self.userData))
6871
6872 __getstate__=_generic_getstate
6873 __setstate__=_generic_setstate
6874
6875 __swig_destroy__ = _Box2D.delete_b2PulleyJointDef
6876 b2PulleyJointDef.Initialize = new_instancemethod(_Box2D.b2PulleyJointDef_Initialize,None,b2PulleyJointDef)
6877 b2PulleyJointDef_swigregister = _Box2D.b2PulleyJointDef_swigregister
6878 b2PulleyJointDef_swigregister(b2PulleyJointDef)
6879 b2_minPulleyLength = cvar.b2_minPulleyLength
6880
6882 """The pulley joint is connected to two bodies and two fixed ground points. The pulley supports a ratio such that: length1 + ratio * length2 <= constant Yes, the force transmitted is scaled by the ratio. The pulley also enforces a maximum length limit on both sides. This is useful to prevent one side of the pulley hitting the top."""
6883 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
6884 __repr__ = _swig_repr
6886 """
6887 GetGroundAnchor1(self) -> b2Vec2
6888
6889 Get the first ground anchor.
6890 """
6891 return _Box2D.b2PulleyJoint_GetGroundAnchor1(self)
6892
6894 """
6895 GetGroundAnchor2(self) -> b2Vec2
6896
6897 Get the second ground anchor.
6898 """
6899 return _Box2D.b2PulleyJoint_GetGroundAnchor2(self)
6900
6902 """
6903 GetLength1(self) -> float32
6904
6905 Get the current length of the segment attached to body1.
6906 """
6907 return _Box2D.b2PulleyJoint_GetLength1(self)
6908
6910 """
6911 GetLength2(self) -> float32
6912
6913 Get the current length of the segment attached to body2.
6914 """
6915 return _Box2D.b2PulleyJoint_GetLength2(self)
6916
6918 """
6919 GetRatio(self) -> float32
6920
6921 Get the pulley ratio.
6922 """
6923 return _Box2D.b2PulleyJoint_GetRatio(self)
6924
6926 """
6927 __init__(self, b2PulleyJointDef data) -> b2PulleyJoint
6928
6929 The pulley joint is connected to two bodies and two fixed ground points. The pulley supports a ratio such that: length1 + ratio * length2 <= constant Yes, the force transmitted is scaled by the ratio. The pulley also enforces a maximum length limit on both sides. This is useful to prevent one side of the pulley hitting the top.
6930 """
6931 _Box2D.b2PulleyJoint_swiginit(self,_Box2D.new_b2PulleyJoint(*args))
6933 """InitVelocityConstraints(self, b2TimeStep step)"""
6934 return _Box2D.b2PulleyJoint_InitVelocityConstraints(self, *args)
6935
6937 """SolveVelocityConstraints(self, b2TimeStep step)"""
6938 return _Box2D.b2PulleyJoint_SolveVelocityConstraints(self, *args)
6939
6941 """SolvePositionConstraints(self, float32 baumgarte) -> bool"""
6942 return _Box2D.b2PulleyJoint_SolvePositionConstraints(self, *args)
6943
6944 ground = _swig_property(_Box2D.b2PulleyJoint_ground_get, _Box2D.b2PulleyJoint_ground_set)
6945 groundAnchor1 = _swig_property(_Box2D.b2PulleyJoint_groundAnchor1_get, _Box2D.b2PulleyJoint_groundAnchor1_set)
6946 groundAnchor2 = _swig_property(_Box2D.b2PulleyJoint_groundAnchor2_get, _Box2D.b2PulleyJoint_groundAnchor2_set)
6947 localAnchor1 = _swig_property(_Box2D.b2PulleyJoint_localAnchor1_get, _Box2D.b2PulleyJoint_localAnchor1_set)
6948 localAnchor2 = _swig_property(_Box2D.b2PulleyJoint_localAnchor2_get, _Box2D.b2PulleyJoint_localAnchor2_set)
6949 u1 = _swig_property(_Box2D.b2PulleyJoint_u1_get, _Box2D.b2PulleyJoint_u1_set)
6950 u2 = _swig_property(_Box2D.b2PulleyJoint_u2_get, _Box2D.b2PulleyJoint_u2_set)
6951 constant = _swig_property(_Box2D.b2PulleyJoint_constant_get, _Box2D.b2PulleyJoint_constant_set)
6952 ratio = _swig_property(_Box2D.b2PulleyJoint_ratio_get, _Box2D.b2PulleyJoint_ratio_set)
6953 maxLength1 = _swig_property(_Box2D.b2PulleyJoint_maxLength1_get, _Box2D.b2PulleyJoint_maxLength1_set)
6954 maxLength2 = _swig_property(_Box2D.b2PulleyJoint_maxLength2_get, _Box2D.b2PulleyJoint_maxLength2_set)
6955 pulleyMass = _swig_property(_Box2D.b2PulleyJoint_pulleyMass_get, _Box2D.b2PulleyJoint_pulleyMass_set)
6956 limitMass1 = _swig_property(_Box2D.b2PulleyJoint_limitMass1_get, _Box2D.b2PulleyJoint_limitMass1_set)
6957 limitMass2 = _swig_property(_Box2D.b2PulleyJoint_limitMass2_get, _Box2D.b2PulleyJoint_limitMass2_set)
6958 impulse = _swig_property(_Box2D.b2PulleyJoint_impulse_get, _Box2D.b2PulleyJoint_impulse_set)
6959 limitImpulse1 = _swig_property(_Box2D.b2PulleyJoint_limitImpulse1_get, _Box2D.b2PulleyJoint_limitImpulse1_set)
6960 limitImpulse2 = _swig_property(_Box2D.b2PulleyJoint_limitImpulse2_get, _Box2D.b2PulleyJoint_limitImpulse2_set)
6961 state = _swig_property(_Box2D.b2PulleyJoint_state_get, _Box2D.b2PulleyJoint_state_set)
6962 limitState1 = _swig_property(_Box2D.b2PulleyJoint_limitState1_get, _Box2D.b2PulleyJoint_limitState1_set)
6963 limitState2 = _swig_property(_Box2D.b2PulleyJoint_limitState2_get, _Box2D.b2PulleyJoint_limitState2_set)
6965 return """b2PulleyJoint(
6966 body1 = %s,
6967 body2 = %s,
6968 collideConnected = %s,
6969 constant = %s,
6970 ground = %s,
6971 groundAnchor1 = %s,
6972 groundAnchor2 = %s,
6973 impulse = %s,
6974 length1 = %s,
6975 length2 = %s,
6976 limitImpulse1 = %s,
6977 limitImpulse2 = %s,
6978 limitMass1 = %s,
6979 limitMass2 = %s,
6980 limitState1 = %s,
6981 limitState2 = %s,
6982 localAnchor1 = %s,
6983 localAnchor2 = %s,
6984 maxLength1 = %s,
6985 maxLength2 = %s,
6986 pulleyMass = %s,
6987 ratio = %s,
6988 state = %s,
6989 type = %s,
6990 u1 = %s,
6991 u2 = %s,
6992 userData = %s,
6993 GetAnchor1() = %s,
6994 GetAnchor2() = %s)"""% tuple(str(a) for a in\
6995 (self.body1,self.body2,self.collideConnected,self.constant,self.ground,self.groundAnchor1,self.groundAnchor2,self.impulse,self.length1,self.length2,self.limitImpulse1,self.limitImpulse2,self.limitMass1,self.limitMass2,self.limitState1,self.limitState2,self.localAnchor1,self.localAnchor2,self.maxLength1,self.maxLength2,self.pulleyMass,self.ratio,self.state,self.type,self.u1,self.u2,self.userData,self.GetAnchor1(),self.GetAnchor2()))
6996
6997 __getstate__=_pickle_get_joint
6998 __setstate__=_pickle_factory_set
6999 _pickle_finalize=_pickle_finalize_joint
7000
7001 length1 = property(GetLength1, None)
7002 length2 = property(GetLength2, None)
7003
7004 __swig_destroy__ = _Box2D.delete_b2PulleyJoint
7005 b2PulleyJoint.GetGroundAnchor1 = new_instancemethod(_Box2D.b2PulleyJoint_GetGroundAnchor1,None,b2PulleyJoint)
7006 b2PulleyJoint.GetGroundAnchor2 = new_instancemethod(_Box2D.b2PulleyJoint_GetGroundAnchor2,None,b2PulleyJoint)
7007 b2PulleyJoint.GetLength1 = new_instancemethod(_Box2D.b2PulleyJoint_GetLength1,None,b2PulleyJoint)
7008 b2PulleyJoint.GetLength2 = new_instancemethod(_Box2D.b2PulleyJoint_GetLength2,None,b2PulleyJoint)
7009 b2PulleyJoint.GetRatio = new_instancemethod(_Box2D.b2PulleyJoint_GetRatio,None,b2PulleyJoint)
7010 b2PulleyJoint.InitVelocityConstraints = new_instancemethod(_Box2D.b2PulleyJoint_InitVelocityConstraints,None,b2PulleyJoint)
7011 b2PulleyJoint.SolveVelocityConstraints = new_instancemethod(_Box2D.b2PulleyJoint_SolveVelocityConstraints,None,b2PulleyJoint)
7012 b2PulleyJoint.SolvePositionConstraints = new_instancemethod(_Box2D.b2PulleyJoint_SolvePositionConstraints,None,b2PulleyJoint)
7013 b2PulleyJoint_swigregister = _Box2D.b2PulleyJoint_swigregister
7014 b2PulleyJoint_swigregister(b2PulleyJoint)
7015
7017 """Revolute joint definition. This requires defining an anchor point where the bodies are joined. The definition uses local anchor points so that the initial configuration can violate the constraint slightly. You also need to specify the initial relative angle for joint limits. This helps when saving and loading a game. The local anchor points are measured from the body's origin rather than the center of mass because: 1. you might not know where the center of mass will be. 2. if you add/remove shapes from a body and recompute the mass, the joints will be broken."""
7018 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
7019 __repr__ = _swig_repr
7021 """
7022 __init__(self) -> b2RevoluteJointDef
7023
7024 Revolute joint definition. This requires defining an anchor point where the bodies are joined. The definition uses local anchor points so that the initial configuration can violate the constraint slightly. You also need to specify the initial relative angle for joint limits. This helps when saving and loading a game. The local anchor points are measured from the body's origin rather than the center of mass because: 1. you might not know where the center of mass will be. 2. if you add/remove shapes from a body and recompute the mass, the joints will be broken.
7025 """
7026 _Box2D.b2RevoluteJointDef_swiginit(self,_Box2D.new_b2RevoluteJointDef())
7028 """
7029 Initialize(self, b2Body body1, b2Body body2, b2Vec2 anchor)
7030
7031 Initialize the bodies, anchors, and reference angle using the world anchor.
7032 """
7033 return _Box2D.b2RevoluteJointDef_Initialize(self, *args)
7034
7035 localAnchor1 = _swig_property(_Box2D.b2RevoluteJointDef_localAnchor1_get, _Box2D.b2RevoluteJointDef_localAnchor1_set)
7036 localAnchor2 = _swig_property(_Box2D.b2RevoluteJointDef_localAnchor2_get, _Box2D.b2RevoluteJointDef_localAnchor2_set)
7037 referenceAngle = _swig_property(_Box2D.b2RevoluteJointDef_referenceAngle_get, _Box2D.b2RevoluteJointDef_referenceAngle_set)
7038 enableLimit = _swig_property(_Box2D.b2RevoluteJointDef_enableLimit_get, _Box2D.b2RevoluteJointDef_enableLimit_set)
7039 lowerAngle = _swig_property(_Box2D.b2RevoluteJointDef_lowerAngle_get, _Box2D.b2RevoluteJointDef_lowerAngle_set)
7040 upperAngle = _swig_property(_Box2D.b2RevoluteJointDef_upperAngle_get, _Box2D.b2RevoluteJointDef_upperAngle_set)
7041 enableMotor = _swig_property(_Box2D.b2RevoluteJointDef_enableMotor_get, _Box2D.b2RevoluteJointDef_enableMotor_set)
7042 motorSpeed = _swig_property(_Box2D.b2RevoluteJointDef_motorSpeed_get, _Box2D.b2RevoluteJointDef_motorSpeed_set)
7043 maxMotorTorque = _swig_property(_Box2D.b2RevoluteJointDef_maxMotorTorque_get, _Box2D.b2RevoluteJointDef_maxMotorTorque_set)
7045 return """b2RevoluteJointDef(
7046 body1 = %s,
7047 body2 = %s,
7048 collideConnected = %s,
7049 enableLimit = %s,
7050 enableMotor = %s,
7051 localAnchor1 = %s,
7052 localAnchor2 = %s,
7053 lowerAngle = %s,
7054 maxMotorTorque = %s,
7055 motorSpeed = %s,
7056 referenceAngle = %s,
7057 type = %s,
7058 upperAngle = %s,
7059 userData = %s)"""% tuple(str(a) for a in\
7060 (self.body1,self.body2,self.collideConnected,self.enableLimit,self.enableMotor,self.localAnchor1,self.localAnchor2,self.lowerAngle,self.maxMotorTorque,self.motorSpeed,self.referenceAngle,self.type,self.upperAngle,self.userData))
7061
7062 __getstate__=_generic_getstate
7063 __setstate__=_generic_setstate
7064
7065 __swig_destroy__ = _Box2D.delete_b2RevoluteJointDef
7066 b2RevoluteJointDef.Initialize = new_instancemethod(_Box2D.b2RevoluteJointDef_Initialize,None,b2RevoluteJointDef)
7067 b2RevoluteJointDef_swigregister = _Box2D.b2RevoluteJointDef_swigregister
7068 b2RevoluteJointDef_swigregister(b2RevoluteJointDef)
7069
7071 """A revolute joint constrains to bodies to share a common point while they are free to rotate about the point. The relative rotation about the shared point is the joint angle. You can limit the relative rotation with a joint limit that specifies a lower and upper angle. You can use a motor to drive the relative rotation about the shared point. A maximum motor torque is provided so that infinite forces are not generated."""
7072 thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
7073 __repr__ = _swig_repr
7075 """
7076 GetJointAngle(self) -> float32
7077
7078 Get the current joint angle in radians.
7079 """
7080 return _Box2D.b2RevoluteJoint_GetJointAngle(self)
7081
7083 """
7084 GetJointSpeed(self) -> float32
7085
7086 Get the current joint angle speed in radians per second.
7087 """
7088 return _Box2D.b2RevoluteJoint_GetJointSpeed(self)
7089
7091 """
7092 IsLimitEnabled(self) -> bool
7093
7094 Is the joint limit enabled?
7095 """
7096 return _Box2D.b2RevoluteJoint_IsLimitEnabled(self)
7097
7099 """
7100 EnableLimit(self, bool flag)
7101
7102 Enable/disable the joint limit.
7103 """
7104 return _Box2D.b2RevoluteJoint_EnableLimit(self, *args)
7105
7107 """
7108 GetLowerLimit(self) -> float32
7109
7110 Get the lower joint limit in radians.
7111 """
7112 return _Box2D.b2RevoluteJoint_GetLowerLimit(self)
7113
7115 """
7116 GetUpperLimit(self) -> float32
7117
7118 Get the upper joint limit in radians.
7119 """
7120 return _Box2D.b2RevoluteJoint_GetUpperLimit(self)
7121
7123 """
7124 SetLimits(self, float32 lower, float32 upper)
7125
7126 Set the joint limits in radians.
7127 """
7128 return _Box2D.b2RevoluteJoint_SetLimits(self, *args)
7129
7131 """
7132 IsMotorEnabled(self) -> bool
7133
7134 Is the joint motor enabled?
7135 """
7136 return _Box2D.b2RevoluteJoint_IsMotorEnabled(self)
7137
7139 """
7140 EnableMotor(self, bool flag)
7141
7142 Enable/disable the joint motor.
7143 """
7144 return _Box2D.b2RevoluteJoint_EnableMotor(self, *args)
7145
7147 """
7148 SetMotorSpeed(self, float32 speed)
7149
7150 Set the motor speed in radians per second.
7151 """
7152 return _Box2D.b2RevoluteJoint_SetMotorSpeed(self, *args)
7153
7155 """
7156 GetMotorSpeed(self) -> float32
7157
7158 Get the motor speed in radians per second.
7159 """
7160 return _Box2D.b2RevoluteJoint_GetMotorSpeed(self)
7161
7163 """
7164 SetMaxMotorTorque(self, float32 torque)
7165
7166 Set the maximum motor torque, usually in N-m.
7167 """
7168 return _Box2D.b2RevoluteJoint_SetMaxMotorTorque(self, *args)
7169
7171 """
7172 GetMotorTorque(self) -> float32
7173
7174 Get the current motor torque, usually in N-m.
7175 """
7176 return _Box2D.b2RevoluteJoint_GetMotorTorque(self)
7177
7179 """
7180 __init__(self, b2RevoluteJointDef _def) -> b2RevoluteJoint
7181
7182 A revolute joint constrains to bodies to share a common point while they are free to rotate about the point. The relative rotation about the shared point is the joint angle. You can limit the relative rotation with a joint limit that specifies a lower and upper angle. You can use a motor to drive the relative rotation about the shared point. A maximum motor torque is provided so that infinite forces are not generated.
7183 """
7184 _Box2D.b2RevoluteJoint_swiginit(self,_Box2D.new_b2RevoluteJoint(*args))
7186 """InitVelocityConstraints(self, b2TimeStep step)"""
7187 return _Box2D.b2RevoluteJoint_InitVelocityConstraints(self, *args)
7188
7190 """SolveVelocityConstraints(self, b2TimeStep step)"""
7191 return _Box2D.b2RevoluteJoint_SolveVelocityConstraints(self, *args)
7192
7194 """SolvePositionConstraints(self, float32 baumgarte) -> bool"""
7195 return _Box2D.b2RevoluteJoint_SolvePositionConstraints(self, *args)
7196
7197 localAnchor1 = _swig_property(_Box2D.b2RevoluteJoint_localAnchor1_get, _Box2D.b2RevoluteJoint_localAnchor1_set)
7198 localAnchor2 = _swig_property(_Box2D.b2RevoluteJoint_localAnchor2_get, _Box2D.b2RevoluteJoint_localAnchor2_set)
7199 impulse = _swig_property(_Box2D.b2RevoluteJoint_impulse_get, _Box2D.b2RevoluteJoint_impulse_set)
7200 motorImpulse = _swig_property(_Box2D.b2RevoluteJoint_motorImpulse_get, _Box2D.b2RevoluteJoint_motorImpulse_set)
7201 mass = _swig_property(_Box2D.b2RevoluteJoint_mass_get, _Box2D.b2RevoluteJoint_mass_set)
7202 motorMass = _swig_property(_Box2D.b2RevoluteJoint_motorMass_get, _Box2D.b2RevoluteJoint_motorMass_set)
7203 enableMotor = _swig_property(_Box2D.b2RevoluteJoint_enableMotor_get, _Box2D.b2RevoluteJoint_enableMotor_set)
7204 maxMotorTorque = _swig_property(_Box2D.b2RevoluteJoint_maxMotorTorque_get, _Box2D.b2RevoluteJoint_maxMotorTorque_set)
7205 motorSpeed = _swig_property(_Box2D.b2RevoluteJoint_motorSpeed_get, _Box2D.b2RevoluteJoint_motorSpeed_set)
7206 enableLimit = _swig_property(_Box2D.b2RevoluteJoint_enableLimit_get, _Box2D.b2RevoluteJoint_enableLimit_set)
7207 referenceAngle = _swig_property(_Box2D.b2RevoluteJoint_referenceAngle_get, _Box2D.b2RevoluteJoint_referenceAngle_set)
7208 lowerAngle = _swig_property(_Box2D.b2RevoluteJoint_lowerAngle_get, _Box2D.b2RevoluteJoint_lowerAngle_set)
7209 upperAngle = _swig_property(_Box2D.b2RevoluteJoint_upperAngle_get, _Box2D.b2RevoluteJoint_upperAngle_set)
7210 limitState = _swig_property(_Box2D.b2RevoluteJoint_limitState_get, _Box2D.b2RevoluteJoint_limitState_set)
7212 return """b2RevoluteJoint(
7213 body1 = %s,
7214 body2 = %s,
7215 collideConnected = %s,
7216 enableLimit = %s,
7217 enableMotor = %s,
7218 impulse = %s,
7219 limitState = %s,
7220 localAnchor1 = %s,
7221 localAnchor2 = %s,
7222 lowerAngle = %s,
7223 mass = %s,
7224 maxMotorTorque = %s,
7225 motorImpulse = %s,
7226 motorMass = %s,
7227 motorSpeed = %s,
7228 referenceAngle = %s,
7229 type = %s,
7230 upperAngle = %s,
7231 userData = %s,
7232 GetAnchor1() = %s,
7233 GetAnchor2() = %s,
7234 GetJointAngle() = %s,
7235 GetJointSpeed() = %s,
7236 GetLowerLimit() = %s,
7237 GetMotorTorque() = %s,
7238 GetUpperLimit() = %s,
7239 IsLimitEnabled() = %s,
7240 IsMotorEnabled() = %s)"""% tuple(str(a) for a in\
7241 (self.body1,self.body2,self.collideConnected,self.enableLimit,self.enableMotor,self.impulse,self.limitState,self.localAnchor1,self.localAnchor2,self.lowerAngle,self.mass,self.maxMotorTorque,self.motorImpulse,self.motorMass,self.motorSpeed,self.referenceAngle,self.type,self.upperAngle,self.userData,self.GetAnchor1(),self.GetAnchor2(),self.GetJointAngle(),self.GetJointSpeed(),self.GetLowerLimit(),self.GetMotorTorque(),self.GetUpperLimit(),self.IsLimitEnabled(),self.IsMotorEnabled()))
7242
7243 __getstate__=_pickle_get_joint
7244 __setstate__=_pickle_factory_set
7245 _pickle_finalize=_pickle_finalize_joint
7246
7247 __swig_destroy__ = _Box2D.delete_b2RevoluteJoint
7248 b2RevoluteJoint.GetJointAngle = new_instancemethod(_Box2D.b2RevoluteJoint_GetJointAngle,None,b2RevoluteJoint)
7249 b2RevoluteJoint.GetJointSpeed = new_instancemethod(_Box2D.b2RevoluteJoint_GetJointSpeed,None,b2RevoluteJoint)
7250 b2RevoluteJoint.IsLimitEnabled = new_instancemethod(_Box2D.b2RevoluteJoint_IsLimitEnabled,None,b2RevoluteJoint)
7251 b2RevoluteJoint.EnableLimit = new_instancemethod(_Box2D.b2RevoluteJoint_EnableLimit,None,b2RevoluteJoint)
7252 b2RevoluteJoint.GetLowerLimit = new_instancemethod(_Box2D.b2RevoluteJoint_GetLowerLimit,None,b2RevoluteJoint)
7253 b2RevoluteJoint.GetUpperLimit = new_instancemethod(_Box2D.b2RevoluteJoint_GetUpperLimit,None,b2RevoluteJoint)
7254 b2RevoluteJoint.SetLimits = new_instancemethod(_Box2D.b2RevoluteJoint_SetLimits,None,b2RevoluteJoint)
7255 b2RevoluteJoint.IsMotorEnabled = new_instancemethod(_Box2D.b2RevoluteJoint_IsMotorEnabled,None,b2RevoluteJoint)
7256 b2RevoluteJoint.EnableMotor = new_instancemethod(_Box2D.b2RevoluteJoint_EnableMotor,None,b2RevoluteJoint)
7257 b2RevoluteJoint.SetMotorSpeed = new_instancemethod(_Box2D.b2RevoluteJoint_SetMotorSpeed,None,b2RevoluteJoint)
7258 b2RevoluteJoint.GetMotorSpeed = new_instancemethod(_Box2D.b2RevoluteJoint_GetMotorSpeed,None,b2RevoluteJoint)
7259 b2RevoluteJoint.SetMaxMotorTorque = new_instancemethod(_Box2D.b2RevoluteJoint_SetMaxMotorTorque,None,b2RevoluteJoint)
7260 b2RevoluteJoint.GetMotorTorque = new_instancemethod(_Box2D.b2RevoluteJoint_GetMotorTorque,None,b2RevoluteJoint)
7261 b2RevoluteJoint.InitVelocityConstraints = new_instancemethod(_Box2D.b2RevoluteJoint_InitVelocityConstraints,None,b2RevoluteJoint)
7262 b2RevoluteJoint.SolveVelocityConstraints = new_instancemethod(_Box2D.b2RevoluteJoint_SolveVelocityConstraints,None,b2RevoluteJoint)
7263 b2RevoluteJoint.SolvePositionConstraints = new_instancemethod(_Box2D.b2RevoluteJoint_SolvePositionConstraints,None,b2RevoluteJoint)
7264 b2RevoluteJoint_swigregister = _Box2D.b2RevoluteJoint_swigregister
7265 b2RevoluteJoint_swigregister(b2RevoluteJoint)
7266