diff options
Diffstat (limited to 'libs/ode-0.16.1/bindings')
| -rw-r--r-- | libs/ode-0.16.1/bindings/python/INSTALL.txt | 64 | ||||
| -rw-r--r-- | libs/ode-0.16.1/bindings/python/TODO.txt | 15 | ||||
| -rwxr-xr-x | libs/ode-0.16.1/bindings/python/demos/tutorial1.py | 49 | ||||
| -rwxr-xr-x | libs/ode-0.16.1/bindings/python/demos/tutorial2.py | 135 | ||||
| -rw-r--r-- | libs/ode-0.16.1/bindings/python/demos/tutorial3.py | 284 | ||||
| -rw-r--r-- | libs/ode-0.16.1/bindings/python/ode.pxd | 503 | ||||
| -rw-r--r-- | libs/ode-0.16.1/bindings/python/ode.pyx | 4506 | ||||
| -rw-r--r-- | libs/ode-0.16.1/bindings/python/setup.py | 48 |
8 files changed, 5604 insertions, 0 deletions
diff --git a/libs/ode-0.16.1/bindings/python/INSTALL.txt b/libs/ode-0.16.1/bindings/python/INSTALL.txt new file mode 100644 index 0000000..a0ae378 --- /dev/null +++ b/libs/ode-0.16.1/bindings/python/INSTALL.txt @@ -0,0 +1,64 @@ +1. REQUIREMENTS:
+
+1. Python 2.4 or higher (http://www.python.org/)
+ - Tested with Python 2.7 (2.6 on earlier builds)
+2. Cython 0.14.1** or higher (http://cython.org/)
+ - Tested with Cython 0.15 (0.14.1 on earlier builds)
+3. ODE shared*** library (or static with -fPIC)
+ - See the notes on building ODE below.
+4. pkg-config (http://www.freedesktop.org/wiki/Software/pkg-config)
+ - Windows executable (and GLib dependency) can be downloaded from
+ http://www.gtk.org/download/win32.php
+ - If you used premake to configure ODE, you may need to create an ode.pc file
+ in your PKG_CONFIG_PATH manually. See <ODE_DIR>/ode.pc.in
+
+
+
+2. BUILDING ODE
+
+ On certain systems (*nix) there is a requirement that a shared library
+ (such as the python module) contains only position-independent code
+ (PIC). In those cases, ODE needs to be either compiled as a shared library
+ too (--enable-shared), or as a static library with PIC (-fPIC).
+
+ Once ODE is built and installed in your desired destination, proceed with
+ building the wrapper.
+
+
+
+3a. BUILDING WITH Visual Studio (Windows)
+
+ python setup.py build_ext
+
+
+3b. BUILDING WITH MINGW (Windows)
+
+ python setup.py build_ext -c mingw32
+
+
+3c. BUILDING WITH GCC/G++ (Linux, OS X, etc.)
+
+ python setup.py build_ext
+
+
+
+4. INSTALLATION
+
+4a. For system-wide installation (needs administrator privileges):
+
+ python setup.py install
+
+4b. For user installation:
+
+ python setup.py install --user
+
+
+
+5. DEMOS and DOCUMENTATION
+
+ Try running the tutorials in the 'demos' directory. The tutorials were taken
+ from the PyODE website (http://pyode.sourceforge.net/).
+
+ For usage documentation, please refer to the PyODE API documentation at
+ http://pyode.sourceforge.net/api-1.2.0/index.html.
+
diff --git a/libs/ode-0.16.1/bindings/python/TODO.txt b/libs/ode-0.16.1/bindings/python/TODO.txt new file mode 100644 index 0000000..356edc4 --- /dev/null +++ b/libs/ode-0.16.1/bindings/python/TODO.txt @@ -0,0 +1,15 @@ +CODE:
+* (setup.py) add package information (version, authors, etc.)
+* (setup.py) add 'install' action
+* (setup.py) add configurable ODE DLL (currently hard-coded to default single precision)
+* (ode.pxd) clean up, add more comments
+* (ode.pyx) refactor for a more Pythonic implementation (e.g. replace getters and setters with
+ properties)?
+* (?) Add option to build bindings in ODE's makefiles
+
+
+DOCS:
+
+* Update and include API docs from PyODE
+* Adapt and include PyODE tutorials/demos
+* Update license text in ode.pxd and ode.pyx
diff --git a/libs/ode-0.16.1/bindings/python/demos/tutorial1.py b/libs/ode-0.16.1/bindings/python/demos/tutorial1.py new file mode 100755 index 0000000..c4266d4 --- /dev/null +++ b/libs/ode-0.16.1/bindings/python/demos/tutorial1.py @@ -0,0 +1,49 @@ +#!/usr/bin/env python + +# http://pyode.sourceforge.net/tutorials/tutorial1.html + +# pyODE example 1: Getting started + +# modified by Gideon Klompje (removed literals and using +# 'ode.Mass.setSphereTotal' instead of 'ode.Mass.setSphere') + +import ode + +# Simulation constants +GRAVITY = (0, -9.81, 0) + +SPHERE_RADIUS = 0.05 +SPHERE_MASS = 1.0 +SPHERE_START_POS = (0, 2, 0) +SPHERE_FORCE = (0, 200, 0) # Initial force to apply to the sphere + +TIME_STEP = 0.04 +TIME_STOP = 2.0 # When to stop the simulation + +# Create a world object +world = ode.World() +world.setGravity(GRAVITY) + +# Create a spherical body inside the world +body = ode.Body(world) +mass = ode.Mass() +mass.setSphereTotal(SPHERE_MASS, SPHERE_RADIUS) +body.setMass(mass) + +body.setPosition(SPHERE_START_POS) +body.addForce(SPHERE_FORCE) + +# Do the simulation... +if __name__ == "__main__": + total_time = 0.0 + while total_time < TIME_STOP: + # output the body's position and velocity + x, y, z = body.getPosition() + u, v, w = body.getLinearVel() + print "%1.2fsec: pos=(%6.3f, %6.3f, %6.3f) vel=(%6.3f, %6.3f, %6.3f)" % \ + (total_time, x, y, z, u, v, w) + + # advance the simulation + world.step(TIME_STEP) + total_time += TIME_STEP + diff --git a/libs/ode-0.16.1/bindings/python/demos/tutorial2.py b/libs/ode-0.16.1/bindings/python/demos/tutorial2.py new file mode 100755 index 0000000..1a4a228 --- /dev/null +++ b/libs/ode-0.16.1/bindings/python/demos/tutorial2.py @@ -0,0 +1,135 @@ +#!/usr/bin/env python + +# http://pyode.sourceforge.net/tutorials/tutorial2.html + +# pyODE example 2: Connecting bodies with joints + +# modified by Gideon Klompje (removed literals and using +# 'ode.Mass.setSphereTotal' instead of 'ode.Mass.setSphere') + + +import ode +import pygame + +from pygame.locals import QUIT, KEYDOWN + +# Constants +WINDOW_RESOLUTION = (640, 480) + +DRAW_SCALE = WINDOW_RESOLUTION[0] / 5 +"""Factor to multiply physical coordinates by to obtain screen size in pixels""" + +DRAW_OFFSET = (WINDOW_RESOLUTION[0] / 2, 50) +"""Screen coordinates (in pixels) that map to the physical origin (0, 0, 0)""" + +BACKGROUND_COLOR = (255, 255, 255) + +GRAVITY = (0, -9.81, 0) + +SPHERE1_POSITION = (1, 0, 0) +SPHERE1_MASS = 1 +SPHERE1_RADIUS = 0.15 +SPHERE1_COLOR = (55, 0, 200) + +SPHERE2_POSITION = (2, 0, 0) +SPHERE2_MASS = 1 +SPHERE2_RADIUS = 0.15 +SPHERE2_COLOR = (55, 0, 200) + +JOINT1_ANCHOR = (0, 0, 0) +JOINT1_COLOR = (200, 0, 55) +JOINT1_WIDTH = 2 +"""Width of the line (in pixels) representing the joint""" + +JOINT2_ANCHOR = SPHERE1_POSITION +JOINT2_COLOR = (200, 0, 55) +JOINT2_WIDTH = 2 +"""Width of the line (in pixels) representing the joint""" + +TIME_STEP = 0.04 + +# Utility functions +def coord(x, y, integer=False): + """ + Convert world coordinates to pixel coordinates. Setting 'integer' to + True will return integer coordinates. + """ + xs = (DRAW_OFFSET[0] + DRAW_SCALE*x) + ys = (DRAW_OFFSET[1] - DRAW_SCALE*y) + + if integer: + return int(round(xs)), int(round(ys)) + else: + return xs, ys + +# Initialize pygame +pygame.init() + +# Open a display +screen = pygame.display.set_mode(WINDOW_RESOLUTION) + +# Create a world object +world = ode.World() +world.setGravity(GRAVITY) + +# Create two bodies +body1 = ode.Body(world) +M = ode.Mass() +M.setSphereTotal(SPHERE1_MASS, SPHERE1_RADIUS) +body1.setMass(M) +body1.setPosition(SPHERE1_POSITION) + +body2 = ode.Body(world) +M = ode.Mass() +M.setSphereTotal(SPHERE2_MASS, SPHERE2_RADIUS) +body2.setMass(M) +body2.setPosition(SPHERE2_POSITION) + +# Connect body1 with the static environment +j1 = ode.BallJoint(world) +j1.attach(body1, ode.environment) +j1.setAnchor(JOINT1_ANCHOR) + +# Connect body2 with body1 +j2 = ode.BallJoint(world) +j2.attach(body1, body2) +j2.setAnchor(JOINT2_ANCHOR) + +# Simulation loop... +if __name__ == "__main__": + fps = 1.0 / TIME_STEP + clk = pygame.time.Clock() + + sph1_rad = int(DRAW_SCALE * SPHERE1_RADIUS) + sph2_rad = int(DRAW_SCALE * SPHERE2_RADIUS) + + loopFlag = True + while loopFlag: + for e in pygame.event.get(): + if e.type==QUIT: + loopFlag=False + if e.type==KEYDOWN: + loopFlag=False + + # Clear the screen + screen.fill(BACKGROUND_COLOR) + + # Draw the two bodies and the lines representing the joints + x1, y1, z1 = body1.getPosition() + x2, y2, z2 = body2.getPosition() + xj1, yj1, zj1 = j1.getAnchor() + xj2, yj2, zj2 = j2.getAnchor() + + pygame.draw.line(screen, JOINT1_COLOR, coord(xj1, yj1), coord(x1, y1), JOINT1_WIDTH) + pygame.draw.line(screen, JOINT2_COLOR, coord(xj2, yj2), coord(x2, y2), JOINT2_WIDTH) + pygame.draw.circle(screen, SPHERE1_COLOR, coord(x1, y1, integer=True), sph1_rad, 0) + pygame.draw.circle(screen, SPHERE2_COLOR, coord(x2, y2, integer=True), sph2_rad, 0) + + pygame.display.flip() + + # Next simulation step + world.step(TIME_STEP) + + # Try to keep the specified framerate + clk.tick(fps) + diff --git a/libs/ode-0.16.1/bindings/python/demos/tutorial3.py b/libs/ode-0.16.1/bindings/python/demos/tutorial3.py new file mode 100644 index 0000000..2644d62 --- /dev/null +++ b/libs/ode-0.16.1/bindings/python/demos/tutorial3.py @@ -0,0 +1,284 @@ +#!/usr/bin/env python + +# http://pyode.sourceforge.net/tutorials/tutorial3.html + +# pyODE example 3: Collision detection + +# Originally by Matthias Baas. +# Updated by Pierre Gay to work without pygame or cgkit. + +import sys, os, random, time +from math import * +from OpenGL.GL import * +from OpenGL.GLU import * +from OpenGL.GLUT import * + +import ode + +# geometric utility functions +def scalp (vec, scal): + vec[0] *= scal + vec[1] *= scal + vec[2] *= scal + +def length (vec): + return sqrt (vec[0]**2 + vec[1]**2 + vec[2]**2) + +# prepare_GL +def prepare_GL(): + """Prepare drawing. + """ + + # Viewport + glViewport(0,0,640,480) + + # Initialize + glClearColor(0.8,0.8,0.9,0) + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + glEnable(GL_DEPTH_TEST) + glDisable(GL_LIGHTING) + glEnable(GL_LIGHTING) + glEnable(GL_NORMALIZE) + glShadeModel(GL_FLAT) + + # Projection + glMatrixMode(GL_PROJECTION) + glLoadIdentity() + gluPerspective (45,1.3333,0.2,20) + + # Initialize ModelView matrix + glMatrixMode(GL_MODELVIEW) + glLoadIdentity() + + # Light source + glLightfv(GL_LIGHT0,GL_POSITION,[0,0,1,0]) + glLightfv(GL_LIGHT0,GL_DIFFUSE,[1,1,1,1]) + glLightfv(GL_LIGHT0,GL_SPECULAR,[1,1,1,1]) + glEnable(GL_LIGHT0) + + # View transformation + gluLookAt (2.4, 3.6, 4.8, 0.5, 0.5, 0, 0, 1, 0) + +# draw_body +def draw_body(body): + """Draw an ODE body. + """ + + x,y,z = body.getPosition() + R = body.getRotation() + rot = [R[0], R[3], R[6], 0., + R[1], R[4], R[7], 0., + R[2], R[5], R[8], 0., + x, y, z, 1.0] + glPushMatrix() + glMultMatrixd(rot) + if body.shape=="box": + sx,sy,sz = body.boxsize + glScalef(sx, sy, sz) + glutSolidCube(1) + glPopMatrix() + + +# create_box +def create_box(world, space, density, lx, ly, lz): + """Create a box body and its corresponding geom.""" + + # Create body + body = ode.Body(world) + M = ode.Mass() + M.setBox(density, lx, ly, lz) + body.setMass(M) + + # Set parameters for drawing the body + body.shape = "box" + body.boxsize = (lx, ly, lz) + + # Create a box geom for collision detection + geom = ode.GeomBox(space, lengths=body.boxsize) + geom.setBody(body) + + return body, geom + +# drop_object +def drop_object(): + """Drop an object into the scene.""" + + global bodies, geom, counter, objcount + + body, geom = create_box(world, space, 1000, 1.0,0.2,0.2) + body.setPosition( (random.gauss(0,0.1),3.0,random.gauss(0,0.1)) ) + theta = random.uniform(0,2*pi) + ct = cos (theta) + st = sin (theta) + body.setRotation([ct, 0., -st, 0., 1., 0., st, 0., ct]) + bodies.append(body) + geoms.append(geom) + counter=0 + objcount+=1 + +# explosion +def explosion(): + """Simulate an explosion. + + Every object is pushed away from the origin. + The force is dependent on the objects distance from the origin. + """ + global bodies + + for b in bodies: + l=b.getPosition () + d = length (l) + a = max(0, 40000*(1.0-0.2*d*d)) + l = [l[0] / 4, l[1], l[2] /4] + scalp (l, a / length (l)) + b.addForce(l) + +# pull +def pull(): + """Pull the objects back to the origin. + + Every object will be pulled back to the origin. + Every couple of frames there'll be a thrust upwards so that + the objects won't stick to the ground all the time. + """ + global bodies, counter + + for b in bodies: + l=list (b.getPosition ()) + scalp (l, -1000 / length (l)) + b.addForce(l) + if counter%60==0: + b.addForce((0,10000,0)) + +# Collision callback +def near_callback(args, geom1, geom2): + """Callback function for the collide() method. + + This function checks if the given geoms do collide and + creates contact joints if they do. + """ + + # Check if the objects do collide + contacts = ode.collide(geom1, geom2) + + # Create contact joints + world,contactgroup = args + for c in contacts: + c.setBounce(0.2) + c.setMu(5000) + j = ode.ContactJoint(world, contactgroup, c) + j.attach(geom1.getBody(), geom2.getBody()) + + + +###################################################################### + +# Initialize Glut +glutInit ([]) + +# Open a window +glutInitDisplayMode (GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE) + +x = 0 +y = 0 +width = 640 +height = 480 +glutInitWindowPosition (x, y); +glutInitWindowSize (width, height); +glutCreateWindow ("testode") + +# Create a world object +world = ode.World() +world.setGravity( (0,-9.81,0) ) +world.setERP(0.8) +world.setCFM(1E-5) + +# Create a space object +space = ode.Space() + +# Create a plane geom which prevent the objects from falling forever +floor = ode.GeomPlane(space, (0,1,0), 0) + +# A list with ODE bodies +bodies = [] + +# The geoms for each of the bodies +geoms = [] + +# A joint group for the contact joints that are generated whenever +# two bodies collide +contactgroup = ode.JointGroup() + +# Some variables used inside the simulation loop +fps = 50 +dt = 1.0/fps +running = True +state = 0 +counter = 0 +objcount = 0 +lasttime = time.time() + + +# keyboard callback +def _keyfunc (c, x, y): + sys.exit (0) + +glutKeyboardFunc (_keyfunc) + +# draw callback +def _drawfunc (): + # Draw the scene + prepare_GL() + for b in bodies: + draw_body(b) + + glutSwapBuffers () + +glutDisplayFunc (_drawfunc) + +# idle callback +def _idlefunc (): + global counter, state, lasttime + + t = dt - (time.time() - lasttime) + if (t > 0): + time.sleep(t) + + counter += 1 + + if state==0: + if counter==20: + drop_object() + if objcount==30: + state=1 + counter=0 + # State 1: Explosion and pulling back the objects + elif state==1: + if counter==100: + explosion() + if counter>300: + pull() + if counter==500: + counter=20 + + glutPostRedisplay () + + # Simulate + n = 4 + + for i in range(n): + # Detect collisions and create contact joints + space.collide((world,contactgroup), near_callback) + + # Simulation step + world.step(dt/n) + + # Remove all contact joints + contactgroup.empty() + + lasttime = time.time() + +glutIdleFunc (_idlefunc) + +glutMainLoop () + diff --git a/libs/ode-0.16.1/bindings/python/ode.pxd b/libs/ode-0.16.1/bindings/python/ode.pxd new file mode 100644 index 0000000..10295c0 --- /dev/null +++ b/libs/ode-0.16.1/bindings/python/ode.pxd @@ -0,0 +1,503 @@ +######################################################################
+# Python Open Dynamics Engine Wrapper
+# Copyright (C) 2004 PyODE developers (see file AUTHORS)
+# All rights reserved.
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of EITHER:
+# (1) The GNU Lesser General Public License as published by the Free
+# Software Foundation; either version 2.1 of the License, or (at
+# your option) any later version. The text of the GNU Lesser
+# General Public License is included with this library in the
+# file LICENSE.
+# (2) The BSD-style license that is included with this library in
+# the file LICENSE-BSD.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the files
+# LICENSE and LICENSE-BSD for more details.
+######################################################################
+
+cdef extern from "stdlib.h":
+
+ void* malloc(long)
+ void free(void*)
+
+cdef extern from "stdio.h":
+ int printf(char*)
+
+# Include the basic floating point type -> dReal (either float or double)
+#include "_precision.pyx"
+
+cdef extern from "ode/ode.h":
+
+ ctypedef double dReal
+
+ # Dummy structs
+ cdef struct dxWorld:
+ int _dummy
+ cdef struct dxSpace:
+ int _dummy
+ cdef struct dxBody:
+ int _dummy
+ cdef struct dxGeom:
+ int _dummy
+ cdef struct dxJoint:
+ int _dummy
+ cdef struct dxJointGroup:
+ int _dummy
+ cdef struct dxTriMeshData:
+ int _dummy
+ cdef struct dxHeightfieldData:
+ int _dummy
+
+ # Types
+ ctypedef dxWorld* dWorldID
+ ctypedef dxSpace* dSpaceID
+ ctypedef dxBody* dBodyID
+ ctypedef dxGeom* dGeomID
+ ctypedef dxJoint* dJointID
+ ctypedef dxJointGroup* dJointGroupID
+ ctypedef dxTriMeshData* dTriMeshDataID
+ ctypedef dxHeightfieldData* dHeightfieldDataID
+ ctypedef dReal dVector3[4]
+ ctypedef dReal dVector4[4]
+ ctypedef dReal dMatrix3[4*3]
+ ctypedef dReal dMatrix4[4*4]
+ ctypedef dReal dMatrix6[8*6]
+ ctypedef dReal dQuaternion[4]
+
+ cdef extern dReal dInfinity
+ cdef extern int dAMotorUser
+ cdef extern int dAMotorEuler
+
+ ctypedef struct dMass:
+ dReal mass
+ dVector4 c
+ dMatrix3 I
+
+ ctypedef struct dJointFeedback:
+ dVector3 f1
+ dVector3 t1
+ dVector3 f2
+ dVector3 t2
+
+ ctypedef void dNearCallback(void* data, dGeomID o1, dGeomID o2)
+ ctypedef dReal dHeightfieldGetHeight( void* p_user_data, int x, int z )
+
+ ctypedef struct dSurfaceParameters:
+ int mode
+ dReal mu
+
+ dReal mu2
+ dReal bounce
+ dReal bounce_vel
+ dReal soft_erp
+ dReal soft_cfm
+ dReal motion1,motion2
+ dReal slip1,slip2
+
+ ctypedef struct dContactGeom:
+ dVector3 pos
+ dVector3 normal
+ dReal depth
+ dGeomID g1,g2
+
+ ctypedef struct dContact:
+ dSurfaceParameters surface
+ dContactGeom geom
+ dVector3 fdir1
+
+
+ # World
+ dWorldID dWorldCreate()
+ void dWorldDestroy (dWorldID)
+
+ void dCloseODE()
+ void dInitODE()
+
+ void dWorldSetGravity (dWorldID, dReal x, dReal y, dReal z)
+ void dWorldGetGravity (dWorldID, dVector3 gravity)
+ void dWorldSetERP (dWorldID, dReal erp)
+ dReal dWorldGetERP (dWorldID)
+ void dWorldSetCFM (dWorldID, dReal cfm)
+ dReal dWorldGetCFM (dWorldID)
+ void dWorldStep (dWorldID, dReal stepsize)
+ void dWorldQuickStep (dWorldID, dReal stepsize)
+ void dWorldSetQuickStepNumIterations (dWorldID, int num)
+ int dWorldGetQuickStepNumIterations (dWorldID)
+ void dWorldSetContactMaxCorrectingVel (dWorldID, dReal vel)
+ dReal dWorldGetContactMaxCorrectingVel (dWorldID)
+ void dWorldSetContactSurfaceLayer (dWorldID, dReal depth)
+ dReal dWorldGetContactSurfaceLayer (dWorldID)
+ void dWorldSetAutoDisableFlag (dWorldID, int do_auto_disable)
+ int dWorldGetAutoDisableFlag (dWorldID)
+ void dWorldSetAutoDisableLinearThreshold (dWorldID, dReal linear_threshold)
+ dReal dWorldGetAutoDisableLinearThreshold (dWorldID)
+ void dWorldSetAutoDisableAngularThreshold (dWorldID, dReal angular_threshold)
+ dReal dWorldGetAutoDisableAngularThreshold (dWorldID)
+ void dWorldSetAutoDisableSteps (dWorldID, int steps)
+ int dWorldGetAutoDisableSteps (dWorldID)
+ void dWorldSetAutoDisableTime (dWorldID, dReal time)
+ dReal dWorldGetAutoDisableTime (dWorldID)
+ dReal dWorldGetLinearDamping (dWorldID)
+ void dWorldSetLinearDamping (dWorldID, dReal scale)
+ dReal dWorldGetAngularDamping (dWorldID)
+ void dWorldSetAngularDamping (dWorldID, dReal scale)
+ void dWorldImpulseToForce (dWorldID, dReal stepsize,
+ dReal ix, dReal iy, dReal iz, dVector3 force)
+
+ # Body
+ dBodyID dBodyCreate (dWorldID)
+ void dBodyDestroy (dBodyID)
+
+ void dBodySetData (dBodyID, void *data)
+ void *dBodyGetData (dBodyID)
+
+ void dBodySetPosition (dBodyID, dReal x, dReal y, dReal z)
+ void dBodySetRotation (dBodyID, dMatrix3 R)
+ void dBodySetQuaternion (dBodyID, dQuaternion q)
+ void dBodySetLinearVel (dBodyID, dReal x, dReal y, dReal z)
+ void dBodySetAngularVel (dBodyID, dReal x, dReal y, dReal z)
+ dReal * dBodyGetPosition (dBodyID)
+ dReal * dBodyGetRotation (dBodyID)
+ dReal * dBodyGetQuaternion (dBodyID)
+ dReal * dBodyGetLinearVel (dBodyID)
+ dReal * dBodyGetAngularVel (dBodyID)
+
+ void dBodySetMass (dBodyID, dMass *mass)
+ void dBodyGetMass (dBodyID, dMass *mass)
+
+ void dBodyAddForce (dBodyID, dReal fx, dReal fy, dReal fz)
+ void dBodyAddTorque (dBodyID, dReal fx, dReal fy, dReal fz)
+ void dBodyAddRelForce (dBodyID, dReal fx, dReal fy, dReal fz)
+ void dBodyAddRelTorque (dBodyID, dReal fx, dReal fy, dReal fz)
+ void dBodyAddForceAtPos (dBodyID, dReal fx, dReal fy, dReal fz, dReal px, dReal py, dReal pz)
+ void dBodyAddForceAtRelPos (dBodyID, dReal fx, dReal fy, dReal fz, dReal px, dReal py, dReal pz)
+ void dBodyAddRelForceAtPos (dBodyID, dReal fx, dReal fy, dReal fz, dReal px, dReal py, dReal pz)
+ void dBodyAddRelForceAtRelPos (dBodyID, dReal fx, dReal fy, dReal fz, dReal px, dReal py, dReal pz)
+
+ dReal * dBodyGetForce (dBodyID)
+ dReal * dBodyGetTorque (dBodyID)
+
+ void dBodySetForce(dBodyID, dReal x, dReal y, dReal z)
+ void dBodySetTorque(dBodyID, dReal x, dReal y, dReal z)
+
+ void dBodyGetRelPointPos (dBodyID, dReal px, dReal py, dReal pz, dVector3 result)
+ void dBodyGetRelPointVel (dBodyID, dReal px, dReal py, dReal pz, dVector3 result)
+ void dBodyGetPointVel (dBodyID, dReal px, dReal py, dReal pz,
+ dVector3 result)
+ void dBodyGetPosRelPoint (dBodyID, dReal px, dReal py, dReal pz,
+ dVector3 result)
+ void dBodyVectorToWorld (dBodyID, dReal px, dReal py, dReal pz,
+ dVector3 result)
+ void dBodyVectorFromWorld (dBodyID, dReal px, dReal py, dReal pz,
+ dVector3 result)
+
+ void dBodySetFiniteRotationMode (dBodyID, int mode)
+ void dBodySetFiniteRotationAxis (dBodyID, dReal x, dReal y, dReal z)
+
+ int dBodyGetFiniteRotationMode (dBodyID)
+ void dBodyGetFiniteRotationAxis (dBodyID, dVector3 result)
+
+ int dBodyGetNumJoints (dBodyID b)
+ dJointID dBodyGetJoint (dBodyID, int index)
+
+ void dBodyEnable (dBodyID)
+ void dBodyDisable (dBodyID)
+ int dBodyIsEnabled (dBodyID)
+
+ void dBodySetGravityMode (dBodyID b, int mode)
+ int dBodyGetGravityMode (dBodyID b)
+
+ void dBodySetDynamic (dBodyID)
+ void dBodySetKinematic (dBodyID)
+ int dBodyIsKinematic (dBodyID)
+
+ void dBodySetMaxAngularSpeed (dBodyID, dReal max_speed)
+
+ # Joints
+ dJointID dJointCreateBall (dWorldID, dJointGroupID)
+ dJointID dJointCreateHinge (dWorldID, dJointGroupID)
+ dJointID dJointCreateSlider (dWorldID, dJointGroupID)
+ dJointID dJointCreateContact (dWorldID, dJointGroupID, dContact *)
+ dJointID dJointCreateUniversal (dWorldID, dJointGroupID)
+ dJointID dJointCreatePR (dWorldID, dJointGroupID)
+ dJointID dJointCreateHinge2 (dWorldID, dJointGroupID)
+ dJointID dJointCreateFixed (dWorldID, dJointGroupID)
+ dJointID dJointCreateNull (dWorldID, dJointGroupID)
+ dJointID dJointCreateAMotor (dWorldID, dJointGroupID)
+ dJointID dJointCreateLMotor (dWorldID, dJointGroupID)
+ dJointID dJointCreatePlane2D (dWorldID, dJointGroupID)
+
+ void dJointDestroy (dJointID)
+
+ void dJointEnable (dJointID)
+ void dJointDisable (dJointID)
+ int dJointIsEnabled (dJointID)
+
+ dJointGroupID dJointGroupCreate (int max_size)
+ void dJointGroupDestroy (dJointGroupID)
+ void dJointGroupEmpty (dJointGroupID)
+
+ void dJointAttach (dJointID, dBodyID body1, dBodyID body2)
+ void dJointSetData (dJointID, void *data)
+ void *dJointGetData (dJointID)
+ int dJointGetType (dJointID)
+ dBodyID dJointGetBody (dJointID, int index)
+
+ void dJointSetBallAnchor (dJointID, dReal x, dReal y, dReal z)
+ void dJointSetHingeAnchor (dJointID, dReal x, dReal y, dReal z)
+ void dJointSetHingeAxis (dJointID, dReal x, dReal y, dReal z)
+ void dJointSetHingeParam (dJointID, int parameter, dReal value)
+ void dJointAddHingeTorque(dJointID joint, dReal torque)
+ void dJointSetSliderAxis (dJointID, dReal x, dReal y, dReal z)
+ void dJointSetSliderParam (dJointID, int parameter, dReal value)
+ void dJointAddSliderForce(dJointID joint, dReal force)
+ void dJointSetHinge2Anchor (dJointID, dReal x, dReal y, dReal z)
+ void dJointSetHinge2Axis1 (dJointID, dReal x, dReal y, dReal z)
+ void dJointSetHinge2Axis2 (dJointID, dReal x, dReal y, dReal z)
+ void dJointSetHinge2Param (dJointID, int parameter, dReal value)
+ void dJointAddHinge2Torques(dJointID joint, dReal torque1, dReal torque2)
+ void dJointSetUniversalAnchor (dJointID, dReal x, dReal y, dReal z)
+ void dJointSetUniversalAxis1 (dJointID, dReal x, dReal y, dReal z)
+ void dJointSetUniversalAxis2 (dJointID, dReal x, dReal y, dReal z)
+ void dJointSetUniversalParam (dJointID, int parameter, dReal value)
+ void dJointAddUniversalTorques(dJointID joint, dReal torque1, dReal torque2)
+ void dJointSetFixed (dJointID)
+ void dJointSetAMotorNumAxes (dJointID, int num)
+ void dJointSetAMotorAxis (dJointID, int anum, int rel, dReal x, dReal y, dReal z)
+ void dJointSetAMotorAngle (dJointID, int anum, dReal angle)
+ void dJointSetAMotorParam (dJointID, int parameter, dReal value)
+ void dJointSetAMotorMode (dJointID, int mode)
+ void dJointAddAMotorTorques (dJointID, dReal torque1, dReal torque2, dReal torque3)
+ void dJointSetLMotorAxis (dJointID, int anum, int rel, dReal x, dReal y, dReal z)
+ void dJointSetLMotorNumAxes (dJointID, int num)
+ void dJointSetLMotorParam (dJointID, int parameter, dReal value)
+
+ void dJointGetBallAnchor (dJointID, dVector3 result)
+ void dJointGetBallAnchor2 (dJointID, dVector3 result)
+ void dJointGetHingeAnchor (dJointID, dVector3 result)
+ void dJointGetHingeAnchor2 (dJointID, dVector3 result)
+ void dJointGetHingeAxis (dJointID, dVector3 result)
+ dReal dJointGetHingeParam (dJointID, int parameter)
+ dReal dJointGetHingeAngle (dJointID)
+ dReal dJointGetHingeAngleRate (dJointID)
+ dReal dJointGetSliderPosition (dJointID)
+ dReal dJointGetSliderPositionRate (dJointID)
+ void dJointGetSliderAxis (dJointID, dVector3 result)
+ dReal dJointGetSliderParam (dJointID, int parameter)
+ void dJointGetHinge2Anchor (dJointID, dVector3 result)
+ void dJointGetHinge2Anchor2 (dJointID, dVector3 result)
+ void dJointGetHinge2Axis1 (dJointID, dVector3 result)
+ void dJointGetHinge2Axis2 (dJointID, dVector3 result)
+ dReal dJointGetHinge2Param (dJointID, int parameter)
+ dReal dJointGetHinge2Angle1 (dJointID)
+ dReal dJointGetHinge2Angle1Rate (dJointID)
+ dReal dJointGetHinge2Angle2Rate (dJointID)
+ void dJointGetUniversalAnchor (dJointID, dVector3 result)
+ void dJointGetUniversalAnchor2 (dJointID, dVector3 result)
+ void dJointGetUniversalAxis1 (dJointID, dVector3 result)
+ void dJointGetUniversalAxis2 (dJointID, dVector3 result)
+ dReal dJointGetUniversalParam (dJointID, int parameter)
+ dReal dJointGetUniversalAngle1 (dJointID)
+ dReal dJointGetUniversalAngle2 (dJointID)
+ dReal dJointGetUniversalAngle1Rate (dJointID)
+ dReal dJointGetUniversalAngle2Rate (dJointID)
+ int dJointGetAMotorNumAxes (dJointID)
+ void dJointGetAMotorAxis (dJointID, int anum, dVector3 result)
+ int dJointGetAMotorAxisRel (dJointID, int anum)
+ dReal dJointGetAMotorAngle (dJointID, int anum)
+ dReal dJointGetAMotorAngleRate (dJointID, int anum)
+ dReal dJointGetAMotorParam (dJointID, int parameter)
+ int dJointGetAMotorMode (dJointID)
+ int dJointGetLMotorNumAxes (dJointID)
+ void dJointGetLMotorAxis (dJointID, int anum, dVector3 result)
+ dReal dJointGetLMotorParam (dJointID, int parameter)
+ void dJointSetPlane2DXParam (dJointID, int parameter, dReal value)
+ void dJointSetPlane2DYParam (dJointID, int parameter, dReal value)
+ void dJointSetPlane2DAngleParam (dJointID, int parameter, dReal value)
+ dReal dJointGetPRPosition (dJointID j)
+ void dJointSetPRAnchor (dJointID j, dReal x, dReal y, dReal z)
+ void dJointSetPRAxis1 (dJointID j, dReal x, dReal y, dReal z)
+ void dJointSetPRAxis2 (dJointID j, dReal x, dReal y, dReal z)
+ void dJointGetPRAnchor (dJointID j, dVector3 result)
+ void dJointGetPRAxis1 (dJointID j, dVector3 result)
+ void dJointGetPRAxis2 (dJointID j, dVector3 result)
+
+ void dJointSetFeedback (dJointID, dJointFeedback *)
+ dJointFeedback *dJointGetFeedback (dJointID)
+
+ int dAreConnected (dBodyID, dBodyID)
+
+ # Mass
+ void dMassSetZero (dMass *)
+ void dMassSetParameters (dMass *, dReal themass,
+ dReal cgx, dReal cgy, dReal cgz,
+ dReal I11, dReal I22, dReal I33,
+ dReal I12, dReal I13, dReal I23)
+ void dMassSetSphere (dMass *, dReal density, dReal radius)
+ void dMassSetSphereTotal (dMass *, dReal total_mass, dReal radius)
+ void dMassSetCapsule (dMass *, dReal density, int direction, dReal radius, dReal length)
+ void dMassSetCapsuleTotal (dMass *, dReal total_mass, int direction, dReal radius, dReal length)
+ void dMassSetCylinder (dMass *, dReal density, int direction,
+ dReal radius, dReal length)
+ void dMassSetCylinderTotal (dMass *, dReal total_mass, int direction,
+ dReal radius, dReal length)
+ void dMassSetBox (dMass *, dReal density,
+ dReal lx, dReal ly, dReal lz)
+ void dMassSetBoxTotal (dMass *, dReal total_mass,
+ dReal lx, dReal ly, dReal lz)
+ void dMassAdjust (dMass *, dReal newmass)
+ void dMassTranslate (dMass *, dReal x, dReal y, dReal z)
+ void dMassRotate (dMass *, dMatrix3 R)
+ void dMassAdd (dMass *a, dMass *b)
+
+ # Space
+# dSpaceID dSimpleSpaceCreate(int space)
+# dSpaceID dHashSpaceCreate(int space)
+ dSpaceID dSimpleSpaceCreate(dSpaceID space)
+ dSpaceID dHashSpaceCreate(dSpaceID space)
+ dSpaceID dQuadTreeSpaceCreate (dSpaceID space, dVector3 Center,
+ dVector3 Extents, int Depth)
+
+ void dSpaceDestroy (dSpaceID)
+ void dSpaceAdd (dSpaceID, dGeomID)
+ void dSpaceRemove (dSpaceID, dGeomID)
+ int dSpaceQuery (dSpaceID, dGeomID)
+ void dSpaceCollide (dSpaceID space, void *data, dNearCallback *callback)
+ void dSpaceCollide2 (dGeomID o1, dGeomID o2, void *data, dNearCallback *callback)
+
+ void dHashSpaceSetLevels (dSpaceID space, int minlevel, int maxlevel)
+ void dHashSpaceGetLevels (dSpaceID space, int *minlevel, int *maxlevel)
+
+ void dSpaceSetCleanup (dSpaceID space, int mode)
+ int dSpaceGetCleanup (dSpaceID space)
+
+ int dSpaceGetNumGeoms (dSpaceID)
+ dGeomID dSpaceGetGeom (dSpaceID, int i)
+
+ # Geom
+ dGeomID dCreateSphere (dSpaceID space, dReal radius)
+ dGeomID dCreateBox (dSpaceID space, dReal lx, dReal ly, dReal lz)
+ dGeomID dCreatePlane (dSpaceID space, dReal a, dReal b, dReal c, dReal d)
+ dGeomID dCreateCapsule (dSpaceID space, dReal radius, dReal length)
+ dGeomID dCreateCylinder (dSpaceID space, dReal radius, dReal length)
+ dGeomID dCreateGeomGroup (dSpaceID space)
+
+ void dGeomSphereSetRadius (dGeomID sphere, dReal radius)
+ void dGeomBoxSetLengths (dGeomID box, dReal lx, dReal ly, dReal lz)
+ void dGeomPlaneSetParams (dGeomID plane, dReal a, dReal b, dReal c, dReal d)
+ void dGeomCapsuleSetParams (dGeomID ccylinder, dReal radius, dReal length)
+ void dGeomCylinderSetParams (dGeomID ccylinder, dReal radius, dReal length)
+
+ dReal dGeomSphereGetRadius (dGeomID sphere)
+ void dGeomBoxGetLengths (dGeomID box, dVector3 result)
+ void dGeomPlaneGetParams (dGeomID plane, dVector4 result)
+ void dGeomCapsuleGetParams (dGeomID ccylinder, dReal *radius, dReal *length)
+ void dGeomCylinderGetParams (dGeomID ccylinder, dReal *radius, dReal *length)
+
+ dReal dGeomSpherePointDepth (dGeomID sphere, dReal x, dReal y, dReal z)
+ dReal dGeomBoxPointDepth (dGeomID box, dReal x, dReal y, dReal z)
+ dReal dGeomPlanePointDepth (dGeomID plane, dReal x, dReal y, dReal z)
+ dReal dGeomCapsulePointDepth (dGeomID ccylinder, dReal x, dReal y, dReal z)
+
+ dGeomID dCreateRay (dSpaceID space, dReal length)
+ void dGeomRaySetLength (dGeomID ray, dReal length)
+ dReal dGeomRayGetLength (dGeomID ray)
+ void dGeomRaySet (dGeomID ray, dReal px, dReal py, dReal pz,
+ dReal dx, dReal dy, dReal dz)
+ void dGeomRayGet (dGeomID ray, dVector3 start, dVector3 dir)
+
+ void dGeomSetData (dGeomID, void *)
+ void *dGeomGetData (dGeomID)
+ void dGeomSetBody (dGeomID, dBodyID)
+ dBodyID dGeomGetBody (dGeomID)
+ void dGeomSetPosition (dGeomID, dReal x, dReal y, dReal z)
+ void dGeomSetRotation (dGeomID, dMatrix3 R)
+ void dGeomSetQuaternion (dGeomID, dQuaternion)
+ dReal * dGeomGetPosition (dGeomID)
+ dReal * dGeomGetRotation (dGeomID)
+ void dGeomGetQuaternion (dGeomID, dQuaternion result)
+ void dGeomSetOffsetPosition (dGeomID, dReal x, dReal y, dReal z)
+ void dGeomSetOffsetRotation (dGeomID, dMatrix3 R)
+ void dGeomClearOffset (dGeomID)
+ dReal * dGeomGetOffsetPosition (dGeomID)
+ dReal * dGeomGetOffsetRotation (dGeomID)
+ void dGeomDestroy (dGeomID)
+ void dGeomGetAABB (dGeomID, dReal aabb[6])
+ dReal *dGeomGetSpaceAABB (dGeomID)
+ int dGeomIsSpace (dGeomID)
+ dSpaceID dGeomGetSpace (dGeomID)
+ int dGeomGetClass (dGeomID)
+
+ void dGeomSetCategoryBits(dGeomID, unsigned long bits)
+ void dGeomSetCollideBits(dGeomID, unsigned long bits)
+ unsigned long dGeomGetCategoryBits(dGeomID)
+ unsigned long dGeomGetCollideBits(dGeomID)
+
+ void dGeomEnable (dGeomID)
+ void dGeomDisable (dGeomID)
+ int dGeomIsEnabled (dGeomID)
+
+ void dGeomGroupAdd (dGeomID group, dGeomID x)
+ void dGeomGroupRemove (dGeomID group, dGeomID x)
+ int dGeomGroupGetNumGeoms (dGeomID group)
+ dGeomID dGeomGroupGetGeom (dGeomID group, int i)
+
+ dGeomID dCreateGeomTransform (dSpaceID space)
+ void dGeomTransformSetGeom (dGeomID g, dGeomID obj)
+ dGeomID dGeomTransformGetGeom (dGeomID g)
+ void dGeomTransformSetCleanup (dGeomID g, int mode)
+ int dGeomTransformGetCleanup (dGeomID g)
+ void dGeomTransformSetInfo (dGeomID g, int mode)
+ int dGeomTransformGetInfo (dGeomID g)
+
+ int dCollide (dGeomID o1, dGeomID o2, int flags, dContactGeom *contact, int skip)
+
+ # Trimesh
+ dTriMeshDataID dGeomTriMeshDataCreate()
+ void dGeomTriMeshDataDestroy(dTriMeshDataID g)
+ void dGeomTriMeshDataBuildSingle1 (dTriMeshDataID g, void* Vertices,
+ int VertexStride, int VertexCount,
+ void* Indices, int IndexCount,
+ int TriStride, void* Normals)
+
+ void dGeomTriMeshDataBuildSimple(dTriMeshDataID g,
+ dReal* Vertices, int VertexCount,
+ int* Indices, int IndexCount)
+
+ dGeomID dCreateTriMesh (dSpaceID space, dTriMeshDataID Data,
+ void* Callback,
+ void* ArrayCallback,
+ void* RayCallback)
+
+ void dGeomTriMeshSetData (dGeomID g, dTriMeshDataID Data)
+
+ void dGeomTriMeshClearTCCache (dGeomID g)
+
+ void dGeomTriMeshGetTriangle (dGeomID g, int Index, dVector3 *v0,
+ dVector3 *v1, dVector3 *v2)
+
+ int dGeomTriMeshGetTriangleCount (dGeomID g)
+
+ void dGeomTriMeshGetPoint (dGeomID g, int Index, dReal u, dReal v,
+ dVector3 Out)
+
+ void dGeomTriMeshEnableTC(dGeomID g, int geomClass, int enable)
+ int dGeomTriMeshIsTCEnabled(dGeomID g, int geomClass)
+
+ # Heightfield
+ dHeightfieldDataID dGeomHeightfieldDataCreate()
+ void dGeomHeightfieldDataDestroy(dHeightfieldDataID g)
+ void dGeomHeightfieldDataBuildCallback(dHeightfieldDataID d,
+ void* pUserData,
+ dHeightfieldGetHeight* pCallback,
+ dReal width, dReal depth,
+ int widthSamples, int depthSamples,
+ dReal scale, dReal offset,
+ dReal thickness, int bWrap)
+ dGeomID dCreateHeightfield (dSpaceID space, dHeightfieldDataID data,
+ int bPlaceable)
+
diff --git a/libs/ode-0.16.1/bindings/python/ode.pyx b/libs/ode-0.16.1/bindings/python/ode.pyx new file mode 100644 index 0000000..92068f2 --- /dev/null +++ b/libs/ode-0.16.1/bindings/python/ode.pyx @@ -0,0 +1,4506 @@ +######################################################################
+# Python Open Dynamics Engine Wrapper
+# Copyright (C) 2004 PyODE developers (see file AUTHORS)
+# All rights reserved.
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of EITHER:
+# (1) The GNU Lesser General Public License as published by the Free
+# Software Foundation; either version 2.1 of the License, or (at
+# your option) any later version. The text of the GNU Lesser
+# General Public License is included with this library in the
+# file LICENSE.
+# (2) The BSD-style license that is included with this library in
+# the file LICENSE-BSD.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the files
+# LICENSE and LICENSE-BSD for more details.
+######################################################################
+
+from ode cimport *
+
+
+paramLoStop = 0
+paramHiStop = 1
+paramVel = 2
+paramLoVel = 3
+paramHiVel = 4
+paramFMax = 5
+paramFudgeFactor = 6
+paramBounce = 7
+paramCFM = 8
+paramStopERP = 9
+paramStopCFM = 10
+paramSuspensionERP = 11
+paramSuspensionCFM = 12
+paramERP = 13
+
+ParamLoStop = 0
+ParamHiStop = 1
+ParamVel = 2
+ParamLoVel = 3
+ParamHiVel = 4
+ParamFMax = 5
+ParamFudgeFactor = 6
+ParamBounce = 7
+ParamCFM = 8
+ParamStopERP = 9
+ParamStopCFM = 10
+ParamSuspensionERP = 11
+ParamSuspensionCFM = 12
+ParamERP = 13
+
+ParamLoStop2 = 256 + 0
+ParamHiStop2 = 256 + 1
+ParamVel2 = 256 + 2
+ParamLoVel2 = 256 + 3
+ParamHiVel2 = 256 + 4
+ParamFMax2 = 256 + 5
+ParamFudgeFactor2 = 256 + 6
+ParamBounce2 = 256 + 7
+ParamCFM2 = 256 + 8
+ParamStopERP2 = 256 + 9
+ParamStopCFM2 = 256 + 10
+ParamSuspensionERP2 = 256 + 11
+ParamSuspensionCFM2 = 256 + 12
+ParamERP2 = 256 + 13
+
+ParamLoStop3 = 512 + 0
+ParamHiStop3 = 512 + 1
+ParamVel3 = 512 + 2
+ParamLoVel3 = 512 + 3
+ParamHiVel3 = 512 + 4
+ParamFMax3 = 512 + 5
+ParamFudgeFactor3 = 512 + 6
+ParamBounce3 = 512 + 7
+ParamCFM3 = 512 + 8
+ParamStopERP3 = 512 + 9
+ParamStopCFM3 = 512 + 10
+ParamSuspensionERP3 = 512 + 11
+ParamSuspensionCFM3 = 512 + 12
+ParamERP3 = 512 + 13
+
+ParamGroup = 256
+
+ContactMu2 = 0x001
+ContactAxisDep = 0x001
+ContactFDir1 = 0x002
+ContactBounce = 0x004
+ContactSoftERP = 0x008
+ContactSoftCFM = 0x010
+ContactMotion1 = 0x020
+ContactMotion2 = 0x040
+ContactMotionN = 0x080
+ContactSlip1 = 0x100
+ContactSlip2 = 0x200
+ContactRolling = 0x400
+
+ContactApprox0 = 0x0000
+ContactApprox1_1 = 0x1000
+ContactApprox1_2 = 0x2000
+ContactApprox1_N = 0x4000
+ContactApprox1 = 0x7000
+
+AMotorUser = dAMotorUser
+AMotorEuler = dAMotorEuler
+
+Infinity = dInfinity
+
+
+import weakref
+_geom_c2py_lut = weakref.WeakValueDictionary()
+
+
+cdef class Mass:
+ """Mass parameters of a rigid body.
+
+ This class stores mass parameters of a rigid body which can be
+ accessed through the following attributes:
+
+ - mass: The total mass of the body (float)
+ - c: The center of gravity position in body frame (3-tuple of floats)
+ - I: The 3x3 inertia tensor in body frame (3-tuple of 3-tuples)
+
+ This class wraps the dMass structure from the C API.
+
+ @ivar mass: The total mass of the body
+ @ivar c: The center of gravity position in body frame (cx, cy, cz)
+ @ivar I: The 3x3 inertia tensor in body frame ((I11, I12, I13), (I12, I22, I23), (I13, I23, I33))
+ @type mass: float
+ @type c: 3-tuple of floats
+ @type I: 3-tuple of 3-tuples of floats
+ """
+ cdef dMass _mass
+
+ def __cinit__(self):
+ dMassSetZero(&self._mass)
+
+ def setZero(self):
+ """setZero()
+
+ Set all the mass parameters to zero."""
+ dMassSetZero(&self._mass)
+
+ def setParameters(self, mass, cgx, cgy, cgz, I11, I22, I33, I12, I13, I23):
+ """setParameters(mass, cgx, cgy, cgz, I11, I22, I33, I12, I13, I23)
+
+ Set the mass parameters to the given values.
+
+ @param mass: Total mass of the body.
+ @param cgx: Center of gravity position in the body frame (x component).
+ @param cgy: Center of gravity position in the body frame (y component).
+ @param cgz: Center of gravity position in the body frame (z component).
+ @param I11: Inertia tensor
+ @param I22: Inertia tensor
+ @param I33: Inertia tensor
+ @param I12: Inertia tensor
+ @param I13: Inertia tensor
+ @param I23: Inertia tensor
+ @type mass: float
+ @type cgx: float
+ @type cgy: float
+ @type cgz: float
+ @type I11: float
+ @type I22: float
+ @type I33: float
+ @type I12: float
+ @type I13: float
+ @type I23: float
+ """
+ dMassSetParameters(&self._mass, mass, cgx, cgy, cgz,
+ I11, I22, I33, I12, I13, I23)
+
+ def setSphere(self, density, radius):
+ """setSphere(density, radius)
+
+ Set the mass parameters to represent a sphere of the given radius
+ and density, with the center of mass at (0,0,0) relative to the body.
+
+ @param density: The density of the sphere
+ @param radius: The radius of the sphere
+ @type density: float
+ @type radius: float
+ """
+ dMassSetSphere(&self._mass, density, radius)
+
+ def setSphereTotal(self, total_mass, radius):
+ """setSphereTotal(total_mass, radius)
+
+ Set the mass parameters to represent a sphere of the given radius
+ and mass, with the center of mass at (0,0,0) relative to the body.
+
+ @param total_mass: The total mass of the sphere
+ @param radius: The radius of the sphere
+ @type total_mass: float
+ @type radius: float
+ """
+ dMassSetSphereTotal(&self._mass, total_mass, radius)
+
+ def setCapsule(self, density, direction, radius, length):
+ """setCapsule(density, direction, radius, length)
+
+ Set the mass parameters to represent a capsule of the given parameters
+ and density, with the center of mass at (0,0,0) relative to the body.
+ The radius of the cylinder (and the spherical cap) is radius. The length
+ of the cylinder (not counting the spherical cap) is length. The
+ cylinder's long axis is oriented along the body's x, y or z axis
+ according to the value of direction (1=x, 2=y, 3=z). The first function
+ accepts the density of the object, the second accepts its total mass.
+
+ @param density: The density of the capsule
+ @param direction: The direction of the capsule's cylinder (1=x axis, 2=y axis, 3=z axis)
+ @param radius: The radius of the capsule's cylinder
+ @param length: The length of the capsule's cylinder (without the caps)
+ @type density: float
+ @type direction: int
+ @type radius: float
+ @type length: float
+ """
+ dMassSetCapsule(&self._mass, density, direction, radius, length)
+
+ def setCapsuleTotal(self, total_mass, direction, radius, length):
+ """setCapsuleTotal(total_mass, direction, radius, length)
+
+ Set the mass parameters to represent a capsule of the given parameters
+ and mass, with the center of mass at (0,0,0) relative to the body. The
+ radius of the cylinder (and the spherical cap) is radius. The length of
+ the cylinder (not counting the spherical cap) is length. The cylinder's
+ long axis is oriented along the body's x, y or z axis according to the
+ value of direction (1=x, 2=y, 3=z). The first function accepts the
+ density of the object, the second accepts its total mass.
+
+ @param total_mass: The total mass of the capsule
+ @param direction: The direction of the capsule's cylinder (1=x axis, 2=y axis, 3=z axis)
+ @param radius: The radius of the capsule's cylinder
+ @param length: The length of the capsule's cylinder (without the caps)
+ @type total_mass: float
+ @type direction: int
+ @type radius: float
+ @type length: float
+ """
+ dMassSetCapsuleTotal(&self._mass, total_mass, direction,
+ radius, length)
+
+ def setCylinder(self, density, direction, r, h):
+ """setCylinder(density, direction, r, h)
+
+ Set the mass parameters to represent a flat-ended cylinder of
+ the given parameters and density, with the center of mass at
+ (0,0,0) relative to the body. The radius of the cylinder is r.
+ The length of the cylinder is h. The cylinder's long axis is
+ oriented along the body's x, y or z axis according to the value
+ of direction (1=x, 2=y, 3=z).
+
+ @param density: The density of the cylinder
+ @param direction: The direction of the cylinder (1=x axis, 2=y axis, 3=z axis)
+ @param r: The radius of the cylinder
+ @param h: The length of the cylinder
+ @type density: float
+ @type direction: int
+ @type r: float
+ @type h: float
+ """
+ dMassSetCylinder(&self._mass, density, direction, r, h)
+
+ def setCylinderTotal(self, total_mass, direction, r, h):
+ """setCylinderTotal(total_mass, direction, r, h)
+
+ Set the mass parameters to represent a flat-ended cylinder of
+ the given parameters and mass, with the center of mass at
+ (0,0,0) relative to the body. The radius of the cylinder is r.
+ The length of the cylinder is h. The cylinder's long axis is
+ oriented along the body's x, y or z axis according to the value
+ of direction (1=x, 2=y, 3=z).
+
+ @param total_mass: The total mass of the cylinder
+ @param direction: The direction of the cylinder (1=x axis, 2=y axis, 3=z axis)
+ @param r: The radius of the cylinder
+ @param h: The length of the cylinder
+ @type total_mass: float
+ @type direction: int
+ @type r: float
+ @type h: float
+ """
+ dMassSetCylinderTotal(&self._mass, total_mass, direction, r, h)
+
+ def setBox(self, density, lx, ly, lz):
+ """setBox(density, lx, ly, lz)
+
+ Set the mass parameters to represent a box of the given
+ dimensions and density, with the center of mass at (0,0,0)
+ relative to the body. The side lengths of the box along the x,
+ y and z axes are lx, ly and lz.
+
+ @param density: The density of the box
+ @param lx: The length along the x axis
+ @param ly: The length along the y axis
+ @param lz: The length along the z axis
+ @type density: float
+ @type lx: float
+ @type ly: float
+ @type lz: float
+ """
+ dMassSetBox(&self._mass, density, lx, ly, lz)
+
+ def setBoxTotal(self, total_mass, lx, ly, lz):
+ """setBoxTotal(total_mass, lx, ly, lz)
+
+ Set the mass parameters to represent a box of the given
+ dimensions and mass, with the center of mass at (0,0,0)
+ relative to the body. The side lengths of the box along the x,
+ y and z axes are lx, ly and lz.
+
+ @param total_mass: The total mass of the box
+ @param lx: The length along the x axis
+ @param ly: The length along the y axis
+ @param lz: The length along the z axis
+ @type total_mass: float
+ @type lx: float
+ @type ly: float
+ @type lz: float
+ """
+ dMassSetBoxTotal(&self._mass, total_mass, lx, ly, lz)
+
+ def adjust(self, newmass):
+ """adjust(newmass)
+
+ Adjust the total mass. Given mass parameters for some object,
+ adjust them so the total mass is now newmass. This is useful
+ when using the setXyz() methods to set the mass parameters for
+ certain objects - they take the object density, not the total
+ mass.
+
+ @param newmass: The new total mass
+ @type newmass: float
+ """
+ dMassAdjust(&self._mass, newmass)
+
+ def translate(self, t):
+ """translate(t)
+
+ Adjust mass parameters. Given mass parameters for some object,
+ adjust them to represent the object displaced by (x,y,z)
+ relative to the body frame.
+
+ @param t: Translation vector (x, y, z)
+ @type t: 3-tuple of floats
+ """
+ dMassTranslate(&self._mass, t[0], t[1], t[2])
+
+# def rotate(self, R):
+# """
+# Given mass parameters for some object, adjust them to
+# represent the object rotated by R relative to the body frame.
+# """
+# pass
+
+ def add(self, Mass b):
+ """add(b)
+
+ Add the mass b to the mass object. Masses can also be added using
+ the + operator.
+
+ @param b: The mass to add to this mass
+ @type b: Mass
+ """
+ dMassAdd(&self._mass, &b._mass)
+
+ def __getattr__(self, name):
+ if name == "mass":
+ return self._mass.mass
+ elif name == "c":
+ return self._mass.c[0], self._mass.c[1], self._mass.c[2]
+ elif name == "I":
+ return ((self._mass.I[0], self._mass.I[1], self._mass.I[2]),
+ (self._mass.I[4], self._mass.I[5], self._mass.I[6]),
+ (self._mass.I[8], self._mass.I[9], self._mass.I[10]))
+ else:
+ raise AttributeError("Mass object has no attribute '%s'" % name)
+
+ def __setattr__(self, name, value):
+ if name == "mass":
+ self.adjust(value)
+ elif name == "c":
+ raise AttributeError("Use the setParameter() method to change c")
+ elif name == "I":
+ raise AttributeError("Use the setParameter() method to change I")
+ else:
+ raise AttributeError("Mass object has no attribute '%s" % name)
+
+ def __add__(self, Mass b):
+ self.add(b)
+ return self
+
+ def __str__(self):
+ m = str(self._mass.mass)
+ sc0 = str(self._mass.c[0])
+ sc1 = str(self._mass.c[1])
+ sc2 = str(self._mass.c[2])
+ I11 = str(self._mass.I[0])
+ I22 = str(self._mass.I[5])
+ I33 = str(self._mass.I[10])
+ I12 = str(self._mass.I[1])
+ I13 = str(self._mass.I[2])
+ I23 = str(self._mass.I[6])
+ return ("Mass=%s\n"
+ "Cg=(%s, %s, %s)\n"
+ "I11=%s I22=%s I33=%s\n"
+ "I12=%s I13=%s I23=%s" %
+ (m, sc0, sc1, sc2, I11, I22, I33, I12, I13, I23))
+# return ("Mass=%s / "
+# "Cg=(%s, %s, %s) / "
+# "I11=%s I22=%s I33=%s "
+# "I12=%s I13=%s I23=%s" %
+# (m, sc0, sc1, sc2, I11, I22, I33, I12, I13, I23))
+
+
+cdef class Contact:
+ """This class represents a contact between two bodies in one point.
+
+ A Contact object stores all the input parameters for a ContactJoint.
+ This class wraps the ODE dContact structure which has 3 components::
+
+ struct dContact {
+ dSurfaceParameters surface;
+ dContactGeom geom;
+ dVector3 fdir1;
+ };
+
+ This wrapper class provides methods to get and set the items of those
+ structures.
+ """
+
+ cdef dContact _contact
+
+ def __cinit__(self):
+ self._contact.surface.mode = ContactBounce
+ self._contact.surface.mu = dInfinity
+
+ self._contact.surface.bounce = 0.1
+
+ # getMode
+ def getMode(self):
+ """getMode() -> flags
+
+ Return the contact flags.
+ """
+ return self._contact.surface.mode
+
+ # setMode
+ def setMode(self, flags):
+ """setMode(flags)
+
+ Set the contact flags. The argument m is a combination of the
+ ContactXyz flags (ContactMu2, ContactBounce, ...).
+
+ @param flags: Contact flags
+ @type flags: int
+ """
+ self._contact.surface.mode = flags
+
+ # getMu
+ def getMu(self):
+ """getMu() -> float
+
+ Return the Coulomb friction coefficient.
+ """
+ return self._contact.surface.mu
+
+ # setMu
+ def setMu(self, mu):
+ """setMu(mu)
+
+ Set the Coulomb friction coefficient.
+
+ @param mu: Coulomb friction coefficient (0..Infinity)
+ @type mu: float
+ """
+ self._contact.surface.mu = mu
+
+ # getMu2
+ def getMu2(self):
+ """getMu2() -> float
+
+ Return the optional Coulomb friction coefficient for direction 2.
+ """
+ return self._contact.surface.mu2
+
+ # setMu2
+ def setMu2(self, mu):
+ """setMu2(mu)
+
+ Set the optional Coulomb friction coefficient for direction 2.
+
+ @param mu: Coulomb friction coefficient (0..Infinity)
+ @type mu: float
+ """
+ self._contact.surface.mu2 = mu
+
+ # getBounce
+ def getBounce(self):
+ """getBounce() -> float
+
+ Return the restitution parameter.
+ """
+ return self._contact.surface.bounce
+
+ # setBounce
+ def setBounce(self, b):
+ """setBounce(b)
+
+ @param b: Restitution parameter (0..1)
+ @type b: float
+ """
+ self._contact.surface.bounce = b
+
+ # getBounceVel
+ def getBounceVel(self):
+ """getBounceVel() -> float
+
+ Return the minimum incoming velocity necessary for bounce.
+ """
+ return self._contact.surface.bounce_vel
+
+ # setBounceVel
+ def setBounceVel(self, bv):
+ """setBounceVel(bv)
+
+ Set the minimum incoming velocity necessary for bounce. Incoming
+ velocities below this will effectively have a bounce parameter of 0.
+
+ @param bv: Velocity
+ @type bv: float
+ """
+ self._contact.surface.bounce_vel = bv
+
+ # getSoftERP
+ def getSoftERP(self):
+ """getSoftERP() -> float
+
+ Return the contact normal "softness" parameter.
+ """
+ return self._contact.surface.soft_erp
+
+ # setSoftERP
+ def setSoftERP(self, erp):
+ """setSoftERP(erp)
+
+ Set the contact normal "softness" parameter.
+
+ @param erp: Softness parameter
+ @type erp: float
+ """
+ self._contact.surface.soft_erp = erp
+
+ # getSoftCFM
+ def getSoftCFM(self):
+ """getSoftCFM() -> float
+
+ Return the contact normal "softness" parameter.
+ """
+ return self._contact.surface.soft_cfm
+
+ # setSoftCFM
+ def setSoftCFM(self, cfm):
+ """setSoftCFM(cfm)
+
+ Set the contact normal "softness" parameter.
+
+ @param cfm: Softness parameter
+ @type cfm: float
+ """
+ self._contact.surface.soft_cfm = cfm
+
+ # getMotion1
+ def getMotion1(self):
+ """getMotion1() -> float
+
+ Get the surface velocity in friction direction 1.
+ """
+ return self._contact.surface.motion1
+
+ # setMotion1
+ def setMotion1(self, m):
+ """setMotion1(m)
+
+ Set the surface velocity in friction direction 1.
+
+ @param m: Surface velocity
+ @type m: float
+ """
+ self._contact.surface.motion1 = m
+
+ # getMotion2
+ def getMotion2(self):
+ """getMotion2() -> float
+
+ Get the surface velocity in friction direction 2.
+ """
+ return self._contact.surface.motion2
+
+ # setMotion2
+ def setMotion2(self, m):
+ """setMotion2(m)
+
+ Set the surface velocity in friction direction 2.
+
+ @param m: Surface velocity
+ @type m: float
+ """
+ self._contact.surface.motion2 = m
+
+ # getSlip1
+ def getSlip1(self):
+ """getSlip1() -> float
+
+ Get the coefficient of force-dependent-slip (FDS) for friction
+ direction 1.
+ """
+ return self._contact.surface.slip1
+
+ # setSlip1
+ def setSlip1(self, s):
+ """setSlip1(s)
+
+ Set the coefficient of force-dependent-slip (FDS) for friction
+ direction 1.
+
+ @param s: FDS coefficient
+ @type s: float
+ """
+ self._contact.surface.slip1 = s
+
+ # getSlip2
+ def getSlip2(self):
+ """getSlip2() -> float
+
+ Get the coefficient of force-dependent-slip (FDS) for friction
+ direction 2.
+ """
+ return self._contact.surface.slip2
+
+ # setSlip2
+ def setSlip2(self, s):
+ """setSlip2(s)
+
+ Set the coefficient of force-dependent-slip (FDS) for friction
+ direction 1.
+
+ @param s: FDS coefficient
+ @type s: float
+ """
+ self._contact.surface.slip2 = s
+
+ # getFDir1
+ def getFDir1(self):
+ """getFDir1() -> (x, y, z)
+
+ Get the "first friction direction" vector that defines a direction
+ along which frictional force is applied.
+ """
+ return (self._contact.fdir1[0],
+ self._contact.fdir1[1],
+ self._contact.fdir1[2])
+
+ # setFDir1
+ def setFDir1(self, fdir):
+ """setFDir1(fdir)
+
+ Set the "first friction direction" vector that defines a direction
+ along which frictional force is applied. It must be of unit length
+ and perpendicular to the contact normal (so it is typically
+ tangential to the contact surface).
+
+ @param fdir: Friction direction
+ @type fdir: 3-sequence of floats
+ """
+ self._contact.fdir1[0] = fdir[0]
+ self._contact.fdir1[1] = fdir[1]
+ self._contact.fdir1[2] = fdir[2]
+
+ # getContactGeomParams
+ def getContactGeomParams(self):
+ """getContactGeomParams() -> (pos, normal, depth, geom1, geom2)
+
+ Get the ContactGeom structure of the contact.
+
+ The return value is a tuple (pos, normal, depth, geom1, geom2)
+ where pos and normal are 3-tuples of floats and depth is a single
+ float. geom1 and geom2 are the Geom objects of the geoms in contact.
+ """
+ cdef size_t id1, id2
+
+ pos = (self._contact.geom.pos[0],
+ self._contact.geom.pos[1],
+ self._contact.geom.pos[2])
+ normal = (self._contact.geom.normal[0],
+ self._contact.geom.normal[1],
+ self._contact.geom.normal[2])
+ depth = self._contact.geom.depth
+
+ id1 = <size_t>self._contact.geom.g1
+ id2 = <size_t>self._contact.geom.g2
+ g1 = _geom_c2py_lut[id1]
+ g2 = _geom_c2py_lut[id2]
+ return pos, normal, depth, g1, g2
+
+ # setContactGeomParams
+ def setContactGeomParams(self, pos, normal, depth, g1=None, g2=None):
+ """setContactGeomParams(pos, normal, depth, geom1=None, geom2=None)
+
+ Set the ContactGeom structure of the contact.
+
+ @param pos: Contact position, in global coordinates
+ @type pos: 3-sequence of floats
+ @param normal: Unit length normal vector
+ @type normal: 3-sequence of floats
+ @param depth: Depth to which the two bodies inter-penetrate
+ @type depth: float
+ @param geom1: Geometry object 1 that collided
+ @type geom1: Geom
+ @param geom2: Geometry object 2 that collided
+ @type geom2: Geom
+ """
+
+ cdef size_t id
+
+ self._contact.geom.pos[0] = pos[0]
+ self._contact.geom.pos[1] = pos[1]
+ self._contact.geom.pos[2] = pos[2]
+ self._contact.geom.normal[0] = normal[0]
+ self._contact.geom.normal[1] = normal[1]
+ self._contact.geom.normal[2] = normal[2]
+ self._contact.geom.depth = depth
+ if g1 != None:
+ id = g1._id()
+ self._contact.geom.g1 = <dGeomID>id
+ else:
+ self._contact.geom.g1 = <dGeomID>0
+
+ if g2 != None:
+ id = g2._id()
+ self._contact.geom.g2 = <dGeomID>id
+ else:
+ self._contact.geom.g2 = <dGeomID>0
+
+
+# World
+cdef class World:
+ """Dynamics world.
+
+ The world object is a container for rigid bodies and joints.
+
+
+ Constructor::
+
+ World()
+ """
+
+ cdef dWorldID wid
+
+ def __cinit__(self):
+ self.wid = dWorldCreate()
+
+ def __dealloc__(self):
+ if self.wid != NULL:
+ dWorldDestroy(self.wid)
+
+ # setGravity
+ def setGravity(self, gravity):
+ """setGravity(gravity)
+
+ Set the world's global gravity vector.
+
+ @param gravity: Gravity vector
+ @type gravity: 3-sequence of floats
+ """
+ dWorldSetGravity(self.wid, gravity[0], gravity[1], gravity[2])
+
+ # getGravity
+ def getGravity(self):
+ """getGravity() -> 3-tuple
+
+ Return the world's global gravity vector as a 3-tuple of floats.
+ """
+ cdef dVector3 g
+ dWorldGetGravity(self.wid, g)
+ return g[0], g[1], g[2]
+
+ # setERP
+ def setERP(self, erp):
+ """setERP(erp)
+
+ Set the global ERP value, that controls how much error
+ correction is performed in each time step. Typical values are
+ in the range 0.1-0.8. The default is 0.2.
+
+ @param erp: Global ERP value
+ @type erp: float
+ """
+ dWorldSetERP(self.wid, erp)
+
+ # getERP
+ def getERP(self):
+ """getERP() -> float
+
+ Get the global ERP value, that controls how much error
+ correction is performed in each time step. Typical values are
+ in the range 0.1-0.8. The default is 0.2.
+ """
+ return dWorldGetERP(self.wid)
+
+ # setCFM
+ def setCFM(self, cfm):
+ """setCFM(cfm)
+
+ Set the global CFM (constraint force mixing) value. Typical
+ values are in the range 10E-9 - 1. The default is 10E-5 if
+ single precision is being used, or 10E-10 if double precision
+ is being used.
+
+ @param cfm: Constraint force mixing value
+ @type cfm: float
+ """
+ dWorldSetCFM(self.wid, cfm)
+
+ # getCFM
+ def getCFM(self):
+ """getCFM() -> float
+
+ Get the global CFM (constraint force mixing) value. Typical
+ values are in the range 10E-9 - 1. The default is 10E-5 if
+ single precision is being used, or 10E-10 if double precision
+ is being used.
+ """
+ return dWorldGetCFM(self.wid)
+
+ # step
+ def step(self, stepsize):
+ """step(stepsize)
+
+ Step the world. This uses a "big matrix" method that takes
+ time on the order of O(m3) and memory on the order of O(m2), where m
+ is the total number of constraint rows.
+
+ For large systems this will use a lot of memory and can be
+ very slow, but this is currently the most accurate method.
+
+ @param stepsize: Time step
+ @type stepsize: float
+ """
+
+ dWorldStep(self.wid, stepsize)
+
+ # quickStep
+ def quickStep(self, stepsize):
+ """quickStep(stepsize)
+
+ Step the world. This uses an iterative method that takes time
+ on the order of O(m*N) and memory on the order of O(m), where m is
+ the total number of constraint rows and N is the number of
+ iterations.
+
+ For large systems this is a lot faster than dWorldStep, but it
+ is less accurate.
+
+ @param stepsize: Time step
+ @type stepsize: float
+ """
+ dWorldQuickStep(self.wid, stepsize)
+
+ # setQuickStepNumIterations
+ def setQuickStepNumIterations(self, num):
+ """setQuickStepNumIterations(num)
+
+ Set the number of iterations that the QuickStep method
+ performs per step. More iterations will give a more accurate
+ solution, but will take longer to compute. The default is 20
+ iterations.
+
+ @param num: Number of iterations
+ @type num: int
+ """
+
+ dWorldSetQuickStepNumIterations(self.wid, num)
+
+ # getQuickStepNumIterations
+ def getQuickStepNumIterations(self):
+ """getQuickStepNumIterations() -> int
+
+ Get the number of iterations that the QuickStep method
+ performs per step. More iterations will give a more accurate
+ solution, but will take longer to compute. The default is 20
+ iterations.
+ """
+ return dWorldGetQuickStepNumIterations(self.wid)
+
+ # setQuickStepNumIterations
+ def setContactMaxCorrectingVel(self, vel):
+ """setContactMaxCorrectingVel(vel)
+
+ Set the maximum correcting velocity that contacts are allowed
+ to generate. The default value is infinity (i.e. no
+ limit). Reducing this value can help prevent "popping" of
+ deeply embedded objects.
+
+ @param vel: Maximum correcting velocity
+ @type vel: float
+ """
+ dWorldSetContactMaxCorrectingVel(self.wid, vel)
+
+ # getQuickStepNumIterations
+ def getContactMaxCorrectingVel(self):
+ """getContactMaxCorrectingVel() -> float
+
+ Get the maximum correcting velocity that contacts are allowed
+ to generate. The default value is infinity (i.e. no
+ limit). Reducing this value can help prevent "popping" of
+ deeply embedded objects.
+
+ """
+ return dWorldGetContactMaxCorrectingVel(self.wid)
+
+ # setContactSurfaceLayer
+ def setContactSurfaceLayer(self, depth):
+ """setContactSurfaceLayer(depth)
+
+ Set the depth of the surface layer around all geometry
+ objects. Contacts are allowed to sink into the surface layer
+ up to the given depth before coming to rest. The default value
+ is zero. Increasing this to some small value (e.g. 0.001) can
+ help prevent jittering problems due to contacts being
+ repeatedly made and broken.
+
+ @param depth: Surface layer depth
+ @type depth: float
+ """
+ dWorldSetContactSurfaceLayer(self.wid, depth)
+
+ # getContactSurfaceLayer
+ def getContactSurfaceLayer(self):
+ """getContactSurfaceLayer()
+
+ Get the depth of the surface layer around all geometry
+ objects. Contacts are allowed to sink into the surface layer
+ up to the given depth before coming to rest. The default value
+ is zero. Increasing this to some small value (e.g. 0.001) can
+ help prevent jittering problems due to contacts being
+ repeatedly made and broken.
+ """
+ return dWorldGetContactSurfaceLayer(self.wid)
+
+ # setAutoDisableFlag
+ def setAutoDisableFlag(self, flag):
+ """setAutoDisableFlag(flag)
+
+ Set the default auto-disable flag for newly created bodies.
+
+ @param flag: True = Do auto disable
+ @type flag: bool
+ """
+ dWorldSetAutoDisableFlag(self.wid, flag)
+
+ # getAutoDisableFlag
+ def getAutoDisableFlag(self):
+ """getAutoDisableFlag() -> bool
+
+ Get the default auto-disable flag for newly created bodies.
+ """
+ return dWorldGetAutoDisableFlag(self.wid)
+
+ # setAutoDisableLinearThreshold
+ def setAutoDisableLinearThreshold(self, threshold):
+ """setAutoDisableLinearThreshold(threshold)
+
+ Set the default auto-disable linear threshold for newly created
+ bodies.
+
+ @param threshold: Linear threshold
+ @type threshold: float
+ """
+ dWorldSetAutoDisableLinearThreshold(self.wid, threshold)
+
+ # getAutoDisableLinearThreshold
+ def getAutoDisableLinearThreshold(self):
+ """getAutoDisableLinearThreshold() -> float
+
+ Get the default auto-disable linear threshold for newly created
+ bodies.
+ """
+ return dWorldGetAutoDisableLinearThreshold(self.wid)
+
+ # setAutoDisableAngularThreshold
+ def setAutoDisableAngularThreshold(self, threshold):
+ """setAutoDisableAngularThreshold(threshold)
+
+ Set the default auto-disable angular threshold for newly created
+ bodies.
+
+ @param threshold: Angular threshold
+ @type threshold: float
+ """
+ dWorldSetAutoDisableAngularThreshold(self.wid, threshold)
+
+ # getAutoDisableAngularThreshold
+ def getAutoDisableAngularThreshold(self):
+ """getAutoDisableAngularThreshold() -> float
+
+ Get the default auto-disable angular threshold for newly created
+ bodies.
+ """
+ return dWorldGetAutoDisableAngularThreshold(self.wid)
+
+ # setAutoDisableSteps
+ def setAutoDisableSteps(self, steps):
+ """setAutoDisableSteps(steps)
+
+ Set the default auto-disable steps for newly created bodies.
+
+ @param steps: Auto disable steps
+ @type steps: int
+ """
+ dWorldSetAutoDisableSteps(self.wid, steps)
+
+ # getAutoDisableSteps
+ def getAutoDisableSteps(self):
+ """getAutoDisableSteps() -> int
+
+ Get the default auto-disable steps for newly created bodies.
+ """
+ return dWorldGetAutoDisableSteps(self.wid)
+
+ # setAutoDisableTime
+ def setAutoDisableTime(self, time):
+ """setAutoDisableTime(time)
+
+ Set the default auto-disable time for newly created bodies.
+
+ @param time: Auto disable time
+ @type time: float
+ """
+ dWorldSetAutoDisableTime(self.wid, time)
+
+ # getAutoDisableTime
+ def getAutoDisableTime(self):
+ """getAutoDisableTime() -> float
+
+ Get the default auto-disable time for newly created bodies.
+ """
+ return dWorldGetAutoDisableTime(self.wid)
+
+ # setLinearDamping
+ def setLinearDamping(self, scale):
+ """setLinearDamping(scale)
+
+ Set the world's linear damping scale.
+ @param scale The linear damping scale that is to be applied to bodies.
+ Default is 0 (no damping). Should be in the interval [0, 1].
+ @type scale: float
+ """
+ dWorldSetLinearDamping(self.wid, scale)
+
+ # getLinearDamping
+ def getLinearDamping(self):
+ """getLinearDamping() -> float
+
+ Get the world's linear damping scale.
+ """
+ return dWorldGetLinearDamping(self.wid)
+
+ # setAngularDamping
+ def setAngularDamping(self, scale):
+ """setAngularDamping(scale)
+
+ Set the world's angular damping scale.
+ @param scale The angular damping scale that is to be applied to bodies.
+ Default is 0 (no damping). Should be in the interval [0, 1].
+ @type scale: float
+ """
+ dWorldSetAngularDamping(self.wid, scale)
+
+ # getAngularDamping
+ def getAngularDamping(self):
+ """getAngularDamping() -> float
+
+ Get the world's angular damping scale.
+ """
+ return dWorldGetAngularDamping(self.wid)
+
+ # impulseToForce
+ def impulseToForce(self, stepsize, impulse):
+ """impulseToForce(stepsize, impulse) -> 3-tuple
+
+ If you want to apply a linear or angular impulse to a rigid
+ body, instead of a force or a torque, then you can use this
+ function to convert the desired impulse into a force/torque
+ vector before calling the dBodyAdd... function.
+
+ @param stepsize: Time step
+ @param impulse: Impulse vector
+ @type stepsize: float
+ @type impulse: 3-tuple of floats
+ """
+ cdef dVector3 force
+ dWorldImpulseToForce(self.wid, stepsize,
+ impulse[0], impulse[1], impulse[2], force)
+ return force[0], force[1], force[2]
+
+ # createBody
+# def createBody(self):
+# return Body(self)
+
+ # createBallJoint
+# def createBallJoint(self, jointgroup=None):
+# return BallJoint(self, jointgroup)
+
+ # createHingeJoint
+# def createHingeJoint(self, jointgroup=None):
+# return HingeJoint(self, jointgroup)
+
+ # createHinge2Joint
+# def createHinge2Joint(self, jointgroup=None):
+# return Hinge2Joint(self, jointgroup)
+
+ # createSliderJoint
+# def createSliderJoint(self, jointgroup=None):
+# return SliderJoint(self, jointgroup)
+
+ # createFixedJoint
+# def createFixedJoint(self, jointgroup=None):
+# return FixedJoint(self, jointgroup)
+
+ # createContactJoint
+# def createContactJoint(self, jointgroup, contact):
+# return ContactJoint(self, jointgroup, contact)
+
+
+# Body
+cdef class Body:
+ """The rigid body class encapsulating the ODE body.
+
+ This class represents a rigid body that has a location and orientation
+ in space and that stores the mass properties of an object.
+
+ When creating a Body object you have to pass the world it belongs to
+ as argument to the constructor::
+
+ >>> import ode
+ >>> w = ode.World()
+ >>> b = ode.Body(w)
+ """
+
+ cdef dBodyID bid
+ # A reference to the world so that the world won't be destroyed while
+ # there are still joints using it.
+ cdef object world
+
+ # A dictionary with user attributes
+ # (set via __getattr__ and __setattr__)
+ cdef object userattribs
+
+ def __cinit__(self, World world not None):
+ self.bid = dBodyCreate(world.wid)
+
+ def __init__(self, World world not None):
+ """Constructor.
+
+ @param world: The world in which the body should be created.
+ @type world: World
+ """
+ self.world = world
+ self.userattribs = {}
+
+ def __dealloc__(self):
+ if self.bid != NULL:
+ dBodyDestroy(self.bid)
+
+ def __getattr__(self, name):
+ try:
+ return self.userattribs[name]
+ except:
+ raise AttributeError("Body object has no attribute '%s'" % name)
+
+ def __setattr__(self, name, value):
+ self.userattribs[name] = value
+
+ def __delattr__(self, name):
+ try:
+ del self.userattribs[name]
+ except:
+ raise AttributeError("Body object has no attribute '%s'" % name)
+
+ # setPosition
+ def setPosition(self, pos):
+ """setPosition(pos)
+
+ Set the position of the body.
+
+ @param pos: The new position
+ @type pos: 3-sequence of floats
+ """
+ dBodySetPosition(self.bid, pos[0], pos[1], pos[2])
+
+ # getPosition
+ def getPosition(self):
+ """getPosition() -> 3-tuple
+
+ Return the current position of the body.
+ """
+ cdef dReal* p
+ # The "const" in the original return value is cast away
+ p = <dReal*>dBodyGetPosition(self.bid)
+ return p[0], p[1], p[2]
+
+ # setRotation
+ def setRotation(self, R):
+ """setRotation(R)
+
+ Set the orientation of the body. The rotation matrix must be
+ given as a sequence of 9 floats which are the elements of the
+ matrix in row-major order.
+
+ @param R: Rotation matrix
+ @type R: 9-sequence of floats
+ """
+ cdef dMatrix3 m
+ m[0] = R[0]
+ m[1] = R[1]
+ m[2] = R[2]
+ m[3] = 0
+ m[4] = R[3]
+ m[5] = R[4]
+ m[6] = R[5]
+ m[7] = 0
+ m[8] = R[6]
+ m[9] = R[7]
+ m[10] = R[8]
+ m[11] = 0
+ dBodySetRotation(self.bid, m)
+
+ # getRotation
+ def getRotation(self):
+ """getRotation() -> 9-tuple
+
+ Return the current rotation matrix as a tuple of 9 floats (row-major
+ order).
+ """
+ cdef dReal* m
+ # The "const" in the original return value is cast away
+ m = <dReal*>dBodyGetRotation(self.bid)
+ return m[0], m[1], m[2], m[4], m[5], m[6], m[8], m[9], m[10]
+
+ # getQuaternion
+ def getQuaternion(self):
+ """getQuaternion() -> 4-tuple
+
+ Return the current rotation as a quaternion. The return value
+ is a list of 4 floats.
+ """
+ cdef dReal* q
+ q = <dReal*>dBodyGetQuaternion(self.bid)
+ return q[0], q[1], q[2], q[3]
+
+ # setQuaternion
+ def setQuaternion(self, q):
+ """setQuaternion(q)
+
+ Set the orientation of the body. The quaternion must be given as a
+ sequence of 4 floats.
+
+ @param q: Quaternion
+ @type q: 4-sequence of floats
+ """
+ cdef dQuaternion w
+ w[0] = q[0]
+ w[1] = q[1]
+ w[2] = q[2]
+ w[3] = q[3]
+ dBodySetQuaternion(self.bid, w)
+
+ # setLinearVel
+ def setLinearVel(self, vel):
+ """setLinearVel(vel)
+
+ Set the linear velocity of the body.
+
+ @param vel: New velocity
+ @type vel: 3-sequence of floats
+ """
+ dBodySetLinearVel(self.bid, vel[0], vel[1], vel[2])
+
+ # getLinearVel
+ def getLinearVel(self):
+ """getLinearVel() -> 3-tuple
+
+ Get the current linear velocity of the body.
+ """
+ cdef dReal* p
+ # The "const" in the original return value is cast away
+ p = <dReal*>dBodyGetLinearVel(self.bid)
+ return p[0], p[1], p[2]
+
+ # setAngularVel
+ def setAngularVel(self, vel):
+ """setAngularVel(vel)
+
+ Set the angular velocity of the body.
+
+ @param vel: New angular velocity
+ @type vel: 3-sequence of floats
+ """
+ dBodySetAngularVel(self.bid, vel[0], vel[1], vel[2])
+
+ # getAngularVel
+ def getAngularVel(self):
+ """getAngularVel() -> 3-tuple
+
+ Get the current angular velocity of the body.
+ """
+ cdef dReal* p
+ # The "const" in the original return value is cast away
+ p = <dReal*>dBodyGetAngularVel(self.bid)
+ return p[0], p[1], p[2]
+
+ # setMass
+ def setMass(self, Mass mass):
+ """setMass(mass)
+
+ Set the mass properties of the body. The argument mass must be
+ an instance of a Mass object.
+
+ @param mass: Mass properties
+ @type mass: Mass
+ """
+ dBodySetMass(self.bid, &mass._mass)
+
+ # getMass
+ def getMass(self):
+ """getMass() -> mass
+
+ Return the mass properties as a Mass object.
+ """
+ cdef Mass m
+ m = Mass()
+ dBodyGetMass(self.bid, &m._mass)
+ return m
+
+ # addForce
+ def addForce(self, f):
+ """addForce(f)
+
+ Add an external force f given in absolute coordinates. The force
+ is applied at the center of mass.
+
+ @param f: Force
+ @type f: 3-sequence of floats
+ """
+ dBodyAddForce(self.bid, f[0], f[1], f[2])
+
+ # addTorque
+ def addTorque(self, t):
+ """addTorque(t)
+
+ Add an external torque t given in absolute coordinates.
+
+ @param t: Torque
+ @type t: 3-sequence of floats
+ """
+ dBodyAddTorque(self.bid, t[0], t[1], t[2])
+
+ # addRelForce
+ def addRelForce(self, f):
+ """addRelForce(f)
+
+ Add an external force f given in relative coordinates
+ (relative to the body's own frame of reference). The force
+ is applied at the center of mass.
+
+ @param f: Force
+ @type f: 3-sequence of floats
+ """
+ dBodyAddRelForce(self.bid, f[0], f[1], f[2])
+
+ # addRelTorque
+ def addRelTorque(self, t):
+ """addRelTorque(t)
+
+ Add an external torque t given in relative coordinates
+ (relative to the body's own frame of reference).
+
+ @param t: Torque
+ @type t: 3-sequence of floats
+ """
+ dBodyAddRelTorque(self.bid, t[0], t[1], t[2])
+
+ # addForceAtPos
+ def addForceAtPos(self, f, p):
+ """addForceAtPos(f, p)
+
+ Add an external force f at position p. Both arguments must be
+ given in absolute coordinates.
+
+ @param f: Force
+ @param p: Position
+ @type f: 3-sequence of floats
+ @type p: 3-sequence of floats
+ """
+ dBodyAddForceAtPos(self.bid, f[0], f[1], f[2], p[0], p[1], p[2])
+
+ # addForceAtRelPos
+ def addForceAtRelPos(self, f, p):
+ """addForceAtRelPos(f, p)
+
+ Add an external force f at position p. f is given in absolute
+ coordinates and p in absolute coordinates.
+
+ @param f: Force
+ @param p: Position
+ @type f: 3-sequence of floats
+ @type p: 3-sequence of floats
+ """
+ dBodyAddForceAtRelPos(self.bid, f[0], f[1], f[2], p[0], p[1], p[2])
+
+ # addRelForceAtPos
+ def addRelForceAtPos(self, f, p):
+ """addRelForceAtPos(f, p)
+
+ Add an external force f at position p. f is given in relative
+ coordinates and p in relative coordinates.
+
+ @param f: Force
+ @param p: Position
+ @type f: 3-sequence of floats
+ @type p: 3-sequence of floats
+ """
+ dBodyAddRelForceAtPos(self.bid, f[0], f[1], f[2], p[0], p[1], p[2])
+
+ # addRelForceAtRelPos
+ def addRelForceAtRelPos(self, f, p):
+ """addRelForceAtRelPos(f, p)
+
+ Add an external force f at position p. Both arguments must be
+ given in relative coordinates.
+
+ @param f: Force
+ @param p: Position
+ @type f: 3-sequence of floats
+ @type p: 3-sequence of floats
+ """
+ dBodyAddRelForceAtRelPos(self.bid, f[0], f[1], f[2], p[0], p[1], p[2])
+
+ # getForce
+ def getForce(self):
+ """getForce() -> 3-tuple
+
+ Return the current accumulated force.
+ """
+ cdef dReal* f
+ # The "const" in the original return value is cast away
+ f = <dReal*>dBodyGetForce(self.bid)
+ return f[0], f[1], f[2]
+
+ # getTorque
+ def getTorque(self):
+ """getTorque() -> 3-tuple
+
+ Return the current accumulated torque.
+ """
+ cdef dReal* f
+ # The "const" in the original return value is cast away
+ f = <dReal*>dBodyGetTorque(self.bid)
+ return f[0], f[1], f[2]
+
+ # setForce
+ def setForce(self, f):
+ """setForce(f)
+
+ Set the body force accumulation vector.
+
+ @param f: Force
+ @type f: 3-tuple of floats
+ """
+ dBodySetForce(self.bid, f[0], f[1], f[2])
+
+ # setTorque
+ def setTorque(self, t):
+ """setTorque(t)
+
+ Set the body torque accumulation vector.
+
+ @param t: Torque
+ @type t: 3-tuple of floats
+ """
+ dBodySetTorque(self.bid, t[0], t[1], t[2])
+
+ # getRelPointPos
+ def getRelPointPos(self, p):
+ """getRelPointPos(p) -> 3-tuple
+
+ Utility function that takes a point p on a body and returns
+ that point's position in global coordinates. The point p
+ must be given in body relative coordinates.
+
+ @param p: Body point (local coordinates)
+ @type p: 3-sequence of floats
+ """
+
+ cdef dVector3 res
+ dBodyGetRelPointPos(self.bid, p[0], p[1], p[2], res)
+ return res[0], res[1], res[2]
+
+ # getRelPointVel
+ def getRelPointVel(self, p):
+ """getRelPointVel(p) -> 3-tuple
+
+ Utility function that takes a point p on a body and returns
+ that point's velocity in global coordinates. The point p
+ must be given in body relative coordinates.
+
+ @param p: Body point (local coordinates)
+ @type p: 3-sequence of floats
+ """
+ cdef dVector3 res
+ dBodyGetRelPointVel(self.bid, p[0], p[1], p[2], res)
+ return res[0], res[1], res[2]
+
+ # getPointVel
+ def getPointVel(self, p):
+ """getPointVel(p) -> 3-tuple
+
+ Utility function that takes a point p on a body and returns
+ that point's velocity in global coordinates. The point p
+ must be given in global coordinates.
+
+ @param p: Body point (global coordinates)
+ @type p: 3-sequence of floats
+ """
+ cdef dVector3 res
+ dBodyGetPointVel(self.bid, p[0], p[1], p[2], res)
+ return res[0], res[1], res[2]
+
+ # getPosRelPoint
+ def getPosRelPoint(self, p):
+ """getPosRelPoint(p) -> 3-tuple
+
+ This is the inverse of getRelPointPos(). It takes a point p in
+ global coordinates and returns the point's position in
+ body-relative coordinates.
+
+ @param p: Body point (global coordinates)
+ @type p: 3-sequence of floats
+ """
+ cdef dVector3 res
+ dBodyGetPosRelPoint(self.bid, p[0], p[1], p[2], res)
+ return res[0], res[1], res[2]
+
+ # vectorToWorld
+ def vectorToWorld(self, v):
+ """vectorToWorld(v) -> 3-tuple
+
+ Given a vector v expressed in the body coordinate system, rotate
+ it to the world coordinate system.
+
+ @param v: Vector in body coordinate system
+ @type v: 3-sequence of floats
+ """
+ cdef dVector3 res
+ dBodyVectorToWorld(self.bid, v[0], v[1], v[2], res)
+ return res[0], res[1], res[2]
+
+ # vectorFromWorld
+ def vectorFromWorld(self, v):
+ """vectorFromWorld(v) -> 3-tuple
+
+ Given a vector v expressed in the world coordinate system, rotate
+ it to the body coordinate system.
+
+ @param v: Vector in world coordinate system
+ @type v: 3-sequence of floats
+ """
+ cdef dVector3 res
+ dBodyVectorFromWorld(self.bid, v[0], v[1], v[2], res)
+ return res[0], res[1], res[2]
+
+ # Enable
+ def enable(self):
+ """enable()
+
+ Manually enable a body.
+ """
+ dBodyEnable(self.bid)
+
+ # Disable
+ def disable(self):
+ """disable()
+
+ Manually disable a body. Note that a disabled body that is connected
+ through a joint to an enabled body will be automatically re-enabled
+ at the next simulation step.
+ """
+ dBodyDisable(self.bid)
+
+ # isEnabled
+ def isEnabled(self):
+ """isEnabled() -> bool
+
+ Check if a body is currently enabled.
+ """
+ return dBodyIsEnabled(self.bid)
+
+ # setFiniteRotationMode
+ def setFiniteRotationMode(self, mode):
+ """setFiniteRotationMode(mode)
+
+ This function controls the way a body's orientation is updated at
+ each time step. The mode argument can be:
+
+ - 0: An "infinitesimal" orientation update is used. This is
+ fast to compute, but it can occasionally cause inaccuracies
+ for bodies that are rotating at high speed, especially when
+ those bodies are joined to other bodies. This is the default
+ for every new body that is created.
+
+ - 1: A "finite" orientation update is used. This is more
+ costly to compute, but will be more accurate for high speed
+ rotations. Note however that high speed rotations can result
+ in many types of error in a simulation, and this mode will
+ only fix one of those sources of error.
+
+ @param mode: Rotation mode (0/1)
+ @type mode: int
+ """
+ dBodySetFiniteRotationMode(self.bid, mode)
+
+ # getFiniteRotationMode
+ def getFiniteRotationMode(self):
+ """getFiniteRotationMode() -> mode (0/1)
+
+ Return the current finite rotation mode of a body (0 or 1).
+ See setFiniteRotationMode().
+ """
+ return dBodyGetFiniteRotationMode(self.bid)
+
+ # setFiniteRotationAxis
+ def setFiniteRotationAxis(self, a):
+ """setFiniteRotationAxis(a)
+
+ Set the finite rotation axis of the body. This axis only has a
+ meaning when the finite rotation mode is set
+ (see setFiniteRotationMode()).
+
+ @param a: Axis
+ @type a: 3-sequence of floats
+ """
+ dBodySetFiniteRotationAxis(self.bid, a[0], a[1], a[2])
+
+ # getFiniteRotationAxis
+ def getFiniteRotationAxis(self):
+ """getFiniteRotationAxis() -> 3-tuple
+
+ Return the current finite rotation axis of the body.
+ """
+ cdef dVector3 p
+ # The "const" in the original return value is cast away
+ dBodyGetFiniteRotationAxis(self.bid, p)
+ return p[0], p[1], p[2]
+
+ # getNumJoints
+ def getNumJoints(self):
+ """getNumJoints() -> int
+
+ Return the number of joints that are attached to this body.
+ """
+ return dBodyGetNumJoints(self.bid)
+
+ # setGravityMode
+ def setGravityMode(self, mode):
+ """setGravityMode(mode)
+
+ Set whether the body is influenced by the world's gravity
+ or not. If mode is True it is, otherwise it isn't.
+ Newly created bodies are always influenced by the world's gravity.
+
+ @param mode: Gravity mode
+ @type mode: bool
+ """
+ dBodySetGravityMode(self.bid, mode)
+
+ # getGravityMode
+ def getGravityMode(self):
+ """getGravityMode() -> bool
+
+ Return True if the body is influenced by the world's gravity.
+ """
+ return dBodyGetGravityMode(self.bid)
+
+ def setDynamic(self):
+ """setDynamic()
+
+ Set a body to the (default) "dynamic" state, instead of "kinematic".
+ See setKinematic() for more information.
+ """
+ dBodySetDynamic(self.bid)
+
+ def setKinematic(self):
+ """setKinematic()
+
+ Set the kinematic state of the body (change it into a kinematic body)
+
+ Kinematic bodies behave as if they had infinite mass. This means they don't react
+ to any force (gravity, constraints or user-supplied); they simply follow
+ velocity to reach the next position. [from ODE wiki]
+
+ """
+ dBodySetKinematic(self.bid)
+
+ def isKinematic(self):
+ """isKinematic() -> bool
+
+ Return True if the body is kinematic (not influenced by other forces).
+
+ Kinematic bodies behave as if they had infinite mass. This means they don't react
+ to any force (gravity, constraints or user-supplied); they simply follow
+ velocity to reach the next position. [from ODE wiki]
+
+ """
+ return dBodyIsKinematic(self.bid)
+
+ def setMaxAngularSpeed(self, max_speed):
+ """setMaxAngularSpeed(max_speed)
+
+ You can also limit the maximum angular speed. In contrast to the damping
+ functions, the angular velocity is affected before the body is moved.
+ This means that it will introduce errors in joints that are forcing the
+ body to rotate too fast. Some bodies have naturally high angular
+ velocities (like cars' wheels), so you may want to give them a very high
+ (like the default, dInfinity) limit.
+
+ """
+ dBodySetMaxAngularSpeed(self.bid, max_speed)
+
+
+# JointGroup
+cdef class JointGroup:
+ """Joint group.
+
+ Constructor::
+
+ JointGroup()
+ """
+
+ # JointGroup ID
+ cdef dJointGroupID gid
+ # A list of Python joints that were added to the group
+ cdef object jointlist
+
+ def __cinit__(self):
+ self.gid = dJointGroupCreate(0)
+
+ def __init__(self):
+ self.jointlist = []
+
+ def __dealloc__(self):
+ if self.gid != NULL:
+ for j in self.jointlist:
+ j._destroyed()
+ dJointGroupDestroy(self.gid)
+
+ # empty
+ def empty(self):
+ """empty()
+
+ Destroy all joints in the group.
+ """
+ dJointGroupEmpty(self.gid)
+ for j in self.jointlist:
+ j._destroyed()
+ self.jointlist = []
+
+ def _addjoint(self, j):
+ """_addjoint(j)
+
+ Add a joint to the group. This is an internal method that is
+ called by the joints. The group has to know the Python
+ wrappers because it has to notify them when the group is
+ emptied (so that the ODE joints won't get destroyed
+ twice). The notification is done by calling _destroyed() on
+ the Python joints.
+
+ @param j: The joint to add
+ @type j: Joint
+ """
+ self.jointlist.append(j)
+
+
+######################################################################
+
+# Joint
+cdef class Joint:
+ """Base class for all joint classes."""
+
+ # Joint id as returned by dJointCreateXxx()
+ cdef dJointID jid
+ # A reference to the world so that the world won't be destroyed while
+ # there are still joints using it.
+ cdef object world
+ # The feedback buffer
+ cdef dJointFeedback* feedback
+
+ cdef object body1
+ cdef object body2
+
+ # A dictionary with user attributes
+ # (set via __getattr__ and __setattr__)
+ cdef object userattribs
+
+ def __cinit__(self, *a, **kw):
+ self.jid = NULL
+ self.world = None
+ self.feedback = NULL
+ self.body1 = None
+ self.body2 = None
+ self.userattribs = {}
+
+ def __init__(self, *a, **kw):
+ raise NotImplementedError("Joint base class can't be used directly")
+
+ def __dealloc__(self):
+ self.setFeedback(False)
+ if self.jid != NULL:
+ dJointDestroy(self.jid)
+
+ def __getattr__(self, name):
+ try:
+ return self.userattribs[name]
+ except:
+ raise AttributeError("Joint object has no attribute '%s'" % name)
+
+ def __setattr__(self, name, value):
+ self.userattribs[name] = value
+
+ def __delattr__(self, name):
+ try:
+ del self.userattribs[name]
+ except:
+ raise AttributeError("Joint object has no attribute '%s'" % name)
+
+ # _destroyed
+ def _destroyed(self):
+ """Notify the joint object about an external destruction of the ODE joint.
+
+ This method has to be called when the underlying ODE object
+ was destroyed by someone else (e.g. by a joint group). The Python
+ wrapper will then refrain from destroying it again.
+ """
+ self.jid = NULL
+
+ # enable
+ def enable(self):
+ """enable()
+
+ Enable the joint. Disabled joints are completely ignored during the
+ simulation. Disabled joints don't lose the already computed information
+ like anchors and axes.
+ """
+ dJointEnable(self.jid)
+
+ # disable
+ def disable(self):
+ """disable()
+
+ Disable the joint. Disabled joints are completely ignored during the
+ simulation. Disabled joints don't lose the already computed information
+ like anchors and axes.
+ """
+ dJointDisable(self.jid)
+
+ # isEnabled
+ def isEnabled(self):
+ """isEnabled() -> bool
+
+ Determine whether the joint is enabled. Disabled joints are completely
+ ignored during the simulation. Disabled joints don't lose the already
+ computed information like anchors and axes.
+ """
+ return dJointIsEnabled(self.jid)
+
+ # attach
+ def attach(self, Body body1, Body body2):
+ """attach(body1, body2)
+
+ Attach the joint to some new bodies. A body can be attached
+ to the environment by passing None as second body.
+
+ @param body1: First body
+ @param body2: Second body
+ @type body1: Body
+ @type body2: Body
+ """
+ cdef dBodyID id1, id2
+
+ if body1 == None:
+ id1 = NULL
+ else:
+ id1 = body1.bid
+
+ if body2 == None:
+ id2 = NULL
+ else:
+ id2 = body2.bid
+
+ self.body1 = body1
+ self.body2 = body2
+ dJointAttach(self.jid, id1, id2)
+
+ # getBody
+ def getBody(self, index):
+ """getBody(index) -> Body
+
+ Return the bodies that this joint connects. If index is 0 the
+ "first" body will be returned, corresponding to the body1
+ argument of the attach() method. If index is 1 the "second" body
+ will be returned, corresponding to the body2 argument of the
+ attach() method.
+
+ @param index: Bodx index (0 or 1).
+ @type index: int
+ """
+
+ if index == 0:
+ return self.body1
+ elif index == 1:
+ return self.body2
+ else:
+ raise IndexError()
+
+ # setFeedback
+ def setFeedback(self, flag=1):
+ """setFeedback(flag=True)
+
+ Create a feedback buffer. If flag is True then a buffer is
+ allocated and the forces/torques applied by the joint can
+ be read using the getFeedback() method. If flag is False the
+ buffer is released.
+
+ @param flag: Specifies whether a buffer should be created or released
+ @type flag: bool
+ """
+
+ if flag:
+ # Was there already a buffer allocated? then we're finished
+ if self.feedback != NULL:
+ return
+ # Allocate a buffer and pass it to ODE
+ self.feedback = <dJointFeedback*>malloc(sizeof(dJointFeedback))
+ if self.feedback == NULL:
+ raise MemoryError("can't allocate feedback buffer")
+ dJointSetFeedback(self.jid, self.feedback)
+ else:
+ if self.feedback != NULL:
+ # Free a previously allocated buffer
+ dJointSetFeedback(self.jid, NULL)
+ free(self.feedback)
+ self.feedback = NULL
+
+ # getFeedback
+ def getFeedback(self):
+ """getFeedback() -> (force1, torque1, force2, torque2)
+
+ Get the forces/torques applied by the joint. If feedback is
+ activated (i.e. setFeedback(True) was called) then this method
+ returns a tuple (force1, torque1, force2, torque2) with the
+ forces and torques applied to body 1 and body 2. The
+ forces/torques are given as 3-tuples.
+
+ If feedback is deactivated then the method always returns None.
+ """
+ cdef dJointFeedback* fb
+
+ fb = dJointGetFeedback(self.jid)
+ if fb == NULL:
+ return None
+
+ f1 = (fb.f1[0], fb.f1[1], fb.f1[2])
+ t1 = (fb.t1[0], fb.t1[1], fb.t1[2])
+ f2 = (fb.f2[0], fb.f2[1], fb.f2[2])
+ t2 = (fb.t2[0], fb.t2[1], fb.t2[2])
+ return f1, t1, f2, t2
+
+######################################################################
+
+
+# BallJoint
+cdef class BallJoint(Joint):
+ """Ball joint.
+
+ Constructor::
+
+ BallJoint(world, jointgroup=None)
+ """
+
+ def __cinit__(self, World world not None, jointgroup=None):
+ cdef JointGroup jg
+ cdef dJointGroupID jgid
+
+ jgid = NULL
+ if jointgroup != None:
+ jg = jointgroup
+ jgid = jg.gid
+ self.jid = dJointCreateBall(world.wid, jgid)
+
+ def __init__(self, World world not None, jointgroup=None):
+ self.world = world
+ if jointgroup != None:
+ jointgroup._addjoint(self)
+
+ # setAnchor
+ def setAnchor(self, pos):
+ """setAnchor(pos)
+
+ Set the joint anchor point which must be specified in world
+ coordinates.
+
+ @param pos: Anchor position
+ @type pos: 3-sequence of floats
+ """
+ dJointSetBallAnchor(self.jid, pos[0], pos[1], pos[2])
+
+ # getAnchor
+ def getAnchor(self):
+ """getAnchor() -> 3-tuple of floats
+
+ Get the joint anchor point, in world coordinates. This
+ returns the point on body 1. If the joint is perfectly
+ satisfied, this will be the same as the point on body 2.
+ """
+
+ cdef dVector3 p
+ dJointGetBallAnchor(self.jid, p)
+ return p[0], p[1], p[2]
+
+ # getAnchor2
+ def getAnchor2(self):
+ """getAnchor2() -> 3-tuple of floats
+
+ Get the joint anchor point, in world coordinates. This
+ returns the point on body 2. If the joint is perfectly
+ satisfied, this will be the same as the point on body 1.
+ """
+
+ cdef dVector3 p
+ dJointGetBallAnchor2(self.jid, p)
+ return p[0], p[1], p[2]
+
+ # setParam
+ def setParam(self, param, value):
+ pass
+
+ # getParam
+ def getParam(self, param):
+ return 0.0
+
+
+# HingeJoint
+cdef class HingeJoint(Joint):
+ """Hinge joint.
+
+ Constructor::
+
+ HingeJoint(world, jointgroup=None)
+ """
+
+ def __cinit__(self, World world not None, jointgroup=None):
+ cdef JointGroup jg
+ cdef dJointGroupID jgid
+
+ jgid = NULL
+ if jointgroup != None:
+ jg = jointgroup
+ jgid = jg.gid
+ self.jid = dJointCreateHinge(world.wid, jgid)
+
+ def __init__(self, World world not None, jointgroup=None):
+ self.world = world
+ if jointgroup != None:
+ jointgroup._addjoint(self)
+
+ # setAnchor
+ def setAnchor(self, pos):
+ """setAnchor(pos)
+
+ Set the hinge anchor which must be given in world coordinates.
+
+ @param pos: Anchor position
+ @type pos: 3-sequence of floats
+ """
+ dJointSetHingeAnchor(self.jid, pos[0], pos[1], pos[2])
+
+ # getAnchor
+ def getAnchor(self):
+ """getAnchor() -> 3-tuple of floats
+
+ Get the joint anchor point, in world coordinates. This returns
+ the point on body 1. If the joint is perfectly satisfied, this
+ will be the same as the point on body 2.
+ """
+ cdef dVector3 p
+ dJointGetHingeAnchor(self.jid, p)
+ return p[0], p[1], p[2]
+
+ # getAnchor2
+ def getAnchor2(self):
+ """getAnchor2() -> 3-tuple of floats
+
+ Get the joint anchor point, in world coordinates. This returns
+ the point on body 2. If the joint is perfectly satisfied, this
+ will be the same as the point on body 1.
+ """
+ cdef dVector3 p
+ dJointGetHingeAnchor2(self.jid, p)
+ return p[0], p[1], p[2]
+
+ # setAxis
+ def setAxis(self, axis):
+ """setAxis(axis)
+
+ Set the hinge axis.
+
+ @param axis: Hinge axis
+ @type axis: 3-sequence of floats
+ """
+ dJointSetHingeAxis(self.jid, axis[0], axis[1], axis[2])
+
+ # getAxis
+ def getAxis(self):
+ """getAxis() -> 3-tuple of floats
+
+ Get the hinge axis.
+ """
+ cdef dVector3 a
+ dJointGetHingeAxis(self.jid, a)
+ return a[0], a[1], a[2]
+
+ # getAngle
+ def getAngle(self):
+ """getAngle() -> float
+
+ Get the hinge angle. The angle is measured between the two
+ bodies, or between the body and the static environment. The
+ angle will be between -pi..pi.
+
+ When the hinge anchor or axis is set, the current position of
+ the attached bodies is examined and that position will be the
+ zero angle.
+ """
+
+ return dJointGetHingeAngle(self.jid)
+
+ # getAngleRate
+ def getAngleRate(self):
+ """getAngleRate() -> float
+
+ Get the time derivative of the angle.
+ """
+ return dJointGetHingeAngleRate(self.jid)
+
+ # addTorque
+ def addTorque(self, torque):
+ """addTorque(torque)
+
+ Applies the torque about the hinge axis.
+
+ @param torque: Torque magnitude
+ @type torque: float
+ """
+ dJointAddHingeTorque(self.jid, torque)
+
+ # setParam
+ def setParam(self, param, value):
+ """setParam(param, value)
+
+ Set limit/motor parameters for the joint.
+
+ param is one of ParamLoStop, ParamHiStop, ParamVel, ParamFMax,
+ ParamFudgeFactor, ParamBounce, ParamCFM, ParamStopERP, ParamStopCFM,
+ ParamSuspensionERP, ParamSuspensionCFM.
+
+ These parameter names can be optionally followed by a digit (2
+ or 3) to indicate the second or third set of parameters.
+
+ @param param: Selects the parameter to set
+ @param value: Parameter value
+ @type param: int
+ @type value: float
+ """
+
+ dJointSetHingeParam(self.jid, param, value)
+
+ # getParam
+ def getParam(self, param):
+ """getParam(param) -> float
+
+ Get limit/motor parameters for the joint.
+
+ param is one of ParamLoStop, ParamHiStop, ParamVel, ParamFMax,
+ ParamFudgeFactor, ParamBounce, ParamCFM, ParamStopERP, ParamStopCFM,
+ ParamSuspensionERP, ParamSuspensionCFM.
+
+ These parameter names can be optionally followed by a digit (2
+ or 3) to indicate the second or third set of parameters.
+
+ @param param: Selects the parameter to read
+ @type param: int
+ """
+ return dJointGetHingeParam(self.jid, param)
+
+
+# SliderJoint
+cdef class SliderJoint(Joint):
+ """Slider joint.
+
+ Constructor::
+
+ SlideJoint(world, jointgroup=None)
+ """
+
+ def __cinit__(self, World world not None, jointgroup=None):
+ cdef JointGroup jg
+ cdef dJointGroupID jgid
+
+ jgid = NULL
+ if jointgroup != None:
+ jg = jointgroup
+ jgid = jg.gid
+ self.jid = dJointCreateSlider(world.wid, jgid)
+
+ def __init__(self, World world not None, jointgroup=None):
+ self.world = world
+ if jointgroup != None:
+ jointgroup._addjoint(self)
+
+ # setAxis
+ def setAxis(self, axis):
+ """setAxis(axis)
+
+ Set the slider axis parameter.
+
+ @param axis: Slider axis
+ @type axis: 3-sequence of floats
+ """
+ dJointSetSliderAxis(self.jid, axis[0], axis[1], axis[2])
+
+ # getAxis
+ def getAxis(self):
+ """getAxis() -> 3-tuple of floats
+
+ Get the slider axis parameter.
+ """
+ cdef dVector3 a
+ dJointGetSliderAxis(self.jid, a)
+ return a[0], a[1], a[2]
+
+ # getPosition
+ def getPosition(self):
+ """getPosition() -> float
+
+ Get the slider linear position (i.e. the slider's "extension").
+
+ When the axis is set, the current position of the attached
+ bodies is examined and that position will be the zero
+ position.
+ """
+
+ return dJointGetSliderPosition(self.jid)
+
+ # getPositionRate
+ def getPositionRate(self):
+ """getPositionRate() -> float
+
+ Get the time derivative of the position.
+ """
+ return dJointGetSliderPositionRate(self.jid)
+
+ # addForce
+ def addForce(self, force):
+ """addForce(force)
+
+ Applies the given force in the slider's direction.
+
+ @param force: Force magnitude
+ @type force: float
+ """
+ dJointAddSliderForce(self.jid, force)
+
+ # setParam
+ def setParam(self, param, value):
+ dJointSetSliderParam(self.jid, param, value)
+
+ # getParam
+ def getParam(self, param):
+ return dJointGetSliderParam(self.jid, param)
+
+
+# UniversalJoint
+cdef class UniversalJoint(Joint):
+ """Universal joint.
+
+ Constructor::
+
+ UniversalJoint(world, jointgroup=None)
+ """
+
+ def __cinit__(self, World world not None, jointgroup=None):
+ cdef JointGroup jg
+ cdef dJointGroupID jgid
+
+ jgid = NULL
+ if jointgroup != None:
+ jg = jointgroup
+ jgid = jg.gid
+ self.jid = dJointCreateUniversal(world.wid, jgid)
+
+ def __init__(self, World world not None, jointgroup=None):
+ self.world = world
+ if jointgroup != None:
+ jointgroup._addjoint(self)
+
+ # setAnchor
+ def setAnchor(self, pos):
+ """setAnchor(pos)
+
+ Set the universal anchor.
+
+ @param pos: Anchor position
+ @type pos: 3-sequence of floats
+ """
+ dJointSetUniversalAnchor(self.jid, pos[0], pos[1], pos[2])
+
+ # getAnchor
+ def getAnchor(self):
+ """getAnchor() -> 3-tuple of floats
+
+ Get the joint anchor point, in world coordinates. This returns
+ the point on body 1. If the joint is perfectly satisfied, this
+ will be the same as the point on body 2.
+ """
+
+ cdef dVector3 p
+ dJointGetUniversalAnchor(self.jid, p)
+ return p[0], p[1], p[2]
+
+ # getAnchor2
+ def getAnchor2(self):
+ """getAnchor2() -> 3-tuple of floats
+
+ Get the joint anchor point, in world coordinates. This returns
+ the point on body 2. If the joint is perfectly satisfied, this
+ will be the same as the point on body 1.
+ """
+
+ cdef dVector3 p
+ dJointGetUniversalAnchor2(self.jid, p)
+ return p[0], p[1], p[2]
+
+ # setAxis1
+ def setAxis1(self, axis):
+ """setAxis1(axis)
+
+ Set the first universal axis. Axis 1 and axis 2 should be
+ perpendicular to each other.
+
+ @param axis: Joint axis
+ @type axis: 3-sequence of floats
+ """
+ dJointSetUniversalAxis1(self.jid, axis[0], axis[1], axis[2])
+
+ # getAxis1
+ def getAxis1(self):
+ """getAxis1() -> 3-tuple of floats
+
+ Get the first univeral axis.
+ """
+ cdef dVector3 a
+ dJointGetUniversalAxis1(self.jid, a)
+ return a[0], a[1], a[2]
+
+ # setAxis2
+ def setAxis2(self, axis):
+ """setAxis2(axis)
+
+ Set the second universal axis. Axis 1 and axis 2 should be
+ perpendicular to each other.
+
+ @param axis: Joint axis
+ @type axis: 3-sequence of floats
+ """
+ dJointSetUniversalAxis2(self.jid, axis[0], axis[1], axis[2])
+
+ # getAxis2
+ def getAxis2(self):
+ """getAxis2() -> 3-tuple of floats
+
+ Get the second univeral axis.
+ """
+ cdef dVector3 a
+ dJointGetUniversalAxis2(self.jid, a)
+ return a[0], a[1], a[2]
+
+ # addTorques
+ def addTorques(self, torque1, torque2):
+ """addTorques(torque1, torque2)
+
+ Applies torque1 about axis 1, and torque2 about axis 2.
+
+ @param torque1: Torque 1 magnitude
+ @param torque2: Torque 2 magnitude
+ @type torque1: float
+ @type torque2: float
+ """
+ dJointAddUniversalTorques(self.jid, torque1, torque2)
+
+ def getAngle1(self):
+ return dJointGetUniversalAngle1(self.jid)
+
+ def getAngle2(self):
+ return dJointGetUniversalAngle2(self.jid)
+
+ def getAngle1Rate(self):
+ return dJointGetUniversalAngle1Rate(self.jid)
+
+ def getAngle2Rate(self):
+ return dJointGetUniversalAngle2Rate(self.jid)
+
+ # setParam
+ def setParam(self, param, value):
+ dJointSetUniversalParam(self.jid, param, value)
+
+ # getParam
+ def getParam(self, param):
+ return dJointGetUniversalParam(self.jid, param)
+
+
+# Hinge2Joint
+cdef class Hinge2Joint(Joint):
+ """Hinge2 joint.
+
+ Constructor::
+
+ Hinge2Joint(world, jointgroup=None)
+ """
+
+ def __cinit__(self, World world not None, jointgroup=None):
+ cdef JointGroup jg
+ cdef dJointGroupID jgid
+
+ jgid = NULL
+ if jointgroup != None:
+ jg = jointgroup
+ jgid = jg.gid
+ self.jid = dJointCreateHinge2(world.wid, jgid)
+
+ def __init__(self, World world, jointgroup=None):
+ self.world = world
+ if jointgroup != None:
+ jointgroup._addjoint(self)
+
+ # setAnchor
+ def setAnchor(self, pos):
+ """setAnchor(pos)
+
+ Set the hinge-2 anchor.
+
+ @param pos: Anchor position
+ @type pos: 3-sequence of floats
+ """
+ dJointSetHinge2Anchor(self.jid, pos[0], pos[1], pos[2])
+
+ # getAnchor
+ def getAnchor(self):
+ """getAnchor() -> 3-tuple of floats
+
+ Get the joint anchor point, in world coordinates. This returns
+ the point on body 1. If the joint is perfectly satisfied, this
+ will be the same as the point on body 2.
+ """
+
+ cdef dVector3 p
+ dJointGetHinge2Anchor(self.jid, p)
+ return p[0], p[1], p[2]
+
+ # getAnchor2
+ def getAnchor2(self):
+ """getAnchor2() -> 3-tuple of floats
+
+ Get the joint anchor point, in world coordinates. This returns
+ the point on body 2. If the joint is perfectly satisfied, this
+ will be the same as the point on body 1.
+ """
+
+ cdef dVector3 p
+ dJointGetHinge2Anchor2(self.jid, p)
+ return p[0], p[1], p[2]
+
+ # setAxis1
+ def setAxis1(self, axis):
+ """setAxis1(axis)
+
+ Set the first hinge-2 axis. Axis 1 and axis 2 must not lie
+ along the same line.
+
+ @param axis: Joint axis
+ @type axis: 3-sequence of floats
+ """
+
+ dJointSetHinge2Axis1(self.jid, axis[0], axis[1], axis[2])
+
+ # getAxis1
+ def getAxis1(self):
+ """getAxis1() -> 3-tuple of floats
+
+ Get the first hinge-2 axis.
+ """
+ cdef dVector3 a
+ dJointGetHinge2Axis1(self.jid, a)
+ return a[0], a[1], a[2]
+
+ # setAxis2
+ def setAxis2(self, axis):
+ """setAxis2(axis)
+
+ Set the second hinge-2 axis. Axis 1 and axis 2 must not lie
+ along the same line.
+
+ @param axis: Joint axis
+ @type axis: 3-sequence of floats
+ """
+ dJointSetHinge2Axis2(self.jid, axis[0], axis[1], axis[2])
+
+ # getAxis2
+ def getAxis2(self):
+ """getAxis2() -> 3-tuple of floats
+
+ Get the second hinge-2 axis.
+ """
+ cdef dVector3 a
+ dJointGetHinge2Axis2(self.jid, a)
+ return a[0], a[1], a[2]
+
+ # getAngle
+ def getAngle1(self):
+ """getAngle1() -> float
+
+ Get the first hinge-2 angle (around axis 1).
+
+ When the anchor or axis is set, the current position of the
+ attached bodies is examined and that position will be the zero
+ angle.
+ """
+ return dJointGetHinge2Angle1(self.jid)
+
+ # getAngle1Rate
+ def getAngle1Rate(self):
+ """getAngle1Rate() -> float
+
+ Get the time derivative of the first hinge-2 angle.
+ """
+ return dJointGetHinge2Angle1Rate(self.jid)
+
+ # getAngle2Rate
+ def getAngle2Rate(self):
+ """getAngle2Rate() -> float
+
+ Get the time derivative of the second hinge-2 angle.
+ """
+ return dJointGetHinge2Angle2Rate(self.jid)
+
+ # addTorques
+ def addTorques(self, torque1, torque2):
+ """addTorques(torque1, torque2)
+
+ Applies torque1 about axis 1, and torque2 about axis 2.
+
+ @param torque1: Torque 1 magnitude
+ @param torque2: Torque 2 magnitude
+ @type torque1: float
+ @type torque2: float
+ """
+ dJointAddHinge2Torques(self.jid, torque1, torque2)
+
+ # setParam
+ def setParam(self, param, value):
+ dJointSetHinge2Param(self.jid, param, value)
+
+ # getParam
+ def getParam(self, param):
+ return dJointGetHinge2Param(self.jid, param)
+
+
+# FixedJoint
+cdef class FixedJoint(Joint):
+ """Fixed joint.
+
+ Constructor::
+
+ FixedJoint(world, jointgroup=None)
+ """
+
+ def __cinit__(self, World world not None, jointgroup=None):
+ cdef JointGroup jg
+ cdef dJointGroupID jgid
+
+ jgid = NULL
+ if jointgroup != None:
+ jg = jointgroup
+ jgid = jg.gid
+ self.jid = dJointCreateFixed(world.wid, jgid)
+
+ def __init__(self, World world not None, jointgroup=None):
+ self.world = world
+ if jointgroup != None:
+ jointgroup._addjoint(self)
+
+ # setFixed
+ def setFixed(self):
+ """setFixed()
+
+ Call this on the fixed joint after it has been attached to
+ remember the current desired relative offset and desired
+ relative rotation between the bodies.
+ """
+ dJointSetFixed(self.jid)
+
+
+# ContactJoint
+cdef class ContactJoint(Joint):
+ """Contact joint.
+
+ Constructor::
+
+ ContactJoint(world, jointgroup, contact)
+ """
+
+ def __cinit__(self, World world not None, jointgroup, Contact contact):
+ cdef JointGroup jg
+ cdef dJointGroupID jgid
+ jgid = NULL
+ if jointgroup != None:
+ jg = jointgroup
+ jgid = jg.gid
+ self.jid = dJointCreateContact(world.wid, jgid, &contact._contact)
+
+ def __init__(self, World world not None, jointgroup, Contact contact):
+ self.world = world
+ if jointgroup != None:
+ jointgroup._addjoint(self)
+
+# AMotor
+cdef class AMotor(Joint):
+ """AMotor joint.
+
+ Constructor::
+
+ AMotor(world, jointgroup=None)
+ """
+
+ def __cinit__(self, World world not None, jointgroup=None):
+ cdef JointGroup jg
+ cdef dJointGroupID jgid
+
+ jgid = NULL
+ if jointgroup != None:
+ jg = jointgroup
+ jgid = jg.gid
+ self.jid = dJointCreateAMotor(world.wid, jgid)
+
+ def __init__(self, World world not None, jointgroup=None):
+ self.world = world
+ if jointgroup != None:
+ jointgroup._addjoint(self)
+
+ # setMode
+ def setMode(self, mode):
+ """setMode(mode)
+
+ Set the angular motor mode. mode must be either AMotorUser or
+ AMotorEuler.
+
+ @param mode: Angular motor mode
+ @type mode: int
+ """
+ dJointSetAMotorMode(self.jid, mode)
+
+ # getMode
+ def getMode(self):
+ """getMode()
+
+ Return the angular motor mode (AMotorUser or AMotorEuler).
+ """
+ return dJointGetAMotorMode(self.jid)
+
+ # setNumAxes
+ def setNumAxes(self, int num):
+ """setNumAxes(num)
+
+ Set the number of angular axes that will be controlled by the AMotor.
+ num may be in the range from 0 to 3.
+
+ @param num: Number of axes (0-3)
+ @type num: int
+ """
+ dJointSetAMotorNumAxes(self.jid, num)
+
+ # getNumAxes
+ def getNumAxes(self):
+ """getNumAxes() -> int
+
+ Get the number of angular axes that are controlled by the AMotor.
+ """
+ return dJointGetAMotorNumAxes(self.jid)
+
+ # setAxis
+ def setAxis(self, int anum, int rel, axis):
+ """setAxis(anum, rel, axis)
+
+ Set an AMotor axis.
+
+ The anum argument selects the axis to change (0,1 or 2).
+ Each axis can have one of three "relative orientation" modes,
+ selected by rel:
+
+ 0: The axis is anchored to the global frame.
+ 1: The axis is anchored to the first body.
+ 2: The axis is anchored to the second body.
+
+ The axis vector is always specified in global coordinates
+ regardless of the setting of rel.
+
+ @param anum: Axis number
+ @param rel: Relative orientation mode
+ @param axis: Axis
+ @type anum: int
+ @type rel: int
+ @type axis: 3-sequence of floats
+ """
+ dJointSetAMotorAxis(self.jid, anum, rel, axis[0], axis[1], axis[2])
+
+ # getAxis
+ def getAxis(self, int anum):
+ """getAxis(anum)
+
+ Get an AMotor axis.
+
+ @param anum: Axis index (0-2)
+ @type anum: int
+ """
+ cdef dVector3 a
+ dJointGetAMotorAxis(self.jid, anum, a)
+ return a[0], a[1], a[2]
+
+ # getAxisRel
+ def getAxisRel(self, int anum):
+ """getAxisRel(anum) -> int
+
+ Get the relative mode of an axis.
+
+ @param anum: Axis index (0-2)
+ @type anum: int
+ """
+ return dJointGetAMotorAxisRel(self.jid, anum)
+
+ # setAngle
+ def setAngle(self, int anum, angle):
+ """setAngle(anum, angle)
+
+ Tell the AMotor what the current angle is along axis anum.
+
+ @param anum: Axis index
+ @param angle: Angle
+ @type anum: int
+ @type angle: float
+ """
+ dJointSetAMotorAngle(self.jid, anum, angle)
+
+ # getAngle
+ def getAngle(self, int anum):
+ """getAngle(anum) -> float
+
+ Return the current angle for axis anum.
+
+ @param anum: Axis index
+ @type anum: int
+ """
+ return dJointGetAMotorAngle(self.jid, anum)
+
+ # getAngleRate
+ def getAngleRate(self, int anum):
+ """getAngleRate(anum) -> float
+
+ Return the current angle rate for axis anum.
+
+ @param anum: Axis index
+ @type anum: int
+ """
+ return dJointGetAMotorAngleRate(self.jid, anum)
+
+ # addTorques
+ def addTorques(self, torque0, torque1, torque2):
+ """addTorques(torque0, torque1, torque2)
+
+ Applies torques about the AMotor's axes.
+
+ @param torque0: Torque 0 magnitude
+ @param torque1: Torque 1 magnitude
+ @param torque2: Torque 2 magnitude
+ @type torque0: float
+ @type torque1: float
+ @type torque2: float
+ """
+ dJointAddAMotorTorques(self.jid, torque0, torque1, torque2)
+
+ # setParam
+ def setParam(self, param, value):
+ dJointSetAMotorParam(self.jid, param, value)
+
+ # getParam
+ def getParam(self, param):
+ return dJointGetAMotorParam(self.jid, param)
+
+
+# LMotor
+cdef class LMotor(Joint):
+ """LMotor joint.
+
+ Constructor::
+
+ LMotor(world, jointgroup=None)
+ """
+
+ def __cinit__(self, World world not None, jointgroup=None):
+ cdef JointGroup jg
+ cdef dJointGroupID jgid
+
+ jgid = NULL
+ if jointgroup != None:
+ jg = jointgroup
+ jgid = jg.gid
+ self.jid = dJointCreateLMotor(world.wid, jgid)
+
+ def __init__(self, World world not None, jointgroup=None):
+ self.world = world
+ if jointgroup != None:
+ jointgroup._addjoint(self)
+
+ # setNumAxes
+ def setNumAxes(self, int num):
+ """setNumAxes(num)
+
+ Set the number of angular axes that will be controlled by the LMotor.
+ num may be in the range from 0 to 3.
+
+ @param num: Number of axes (0-3)
+ @type num: int
+ """
+ dJointSetLMotorNumAxes(self.jid, num)
+
+ # getNumAxes
+ def getNumAxes(self):
+ """getNumAxes() -> int
+
+ Get the number of angular axes that are controlled by the LMotor.
+ """
+ return dJointGetLMotorNumAxes(self.jid)
+
+ # setAxis
+ def setAxis(self, int anum, int rel, axis):
+ """setAxis(anum, rel, axis)
+
+ Set an LMotor axis.
+
+ The anum argument selects the axis to change (0,1 or 2).
+ Each axis can have one of three "relative orientation" modes,
+ selected by rel:
+
+ 0: The axis is anchored to the global frame.
+ 1: The axis is anchored to the first body.
+ 2: The axis is anchored to the second body.
+
+ @param anum: Axis number
+ @param rel: Relative orientation mode
+ @param axis: Axis
+ @type anum: int
+ @type rel: int
+ @type axis: 3-sequence of floats
+ """
+ dJointSetLMotorAxis(self.jid, anum, rel, axis[0], axis[1], axis[2])
+
+ # getAxis
+ def getAxis(self, int anum):
+ """getAxis(anum)
+
+ Get an LMotor axis.
+
+ @param anum: Axis index (0-2)
+ @type anum: int
+ """
+ cdef dVector3 a
+ dJointGetLMotorAxis(self.jid, anum, a)
+ return a[0], a[1], a[2]
+
+ # setParam
+ def setParam(self, param, value):
+ dJointSetLMotorParam(self.jid, param, value)
+
+ # getParam
+ def getParam(self, param):
+ return dJointGetLMotorParam(self.jid, param)
+
+
+# Plane2DJoint
+cdef class Plane2DJoint(Joint):
+ """Plane-2D Joint.
+
+ Constructor::
+
+ Plane2DJoint(world, jointgroup=None)
+ """
+
+ def __cinit__(self, World world not None, jointgroup=None):
+ cdef JointGroup jg
+ cdef dJointGroupID jgid
+
+ jgid = NULL
+ if jointgroup != None:
+ jg = jointgroup
+ jgid = jg.gid
+ self.jid = dJointCreatePlane2D(world.wid, jgid)
+
+ def __init__(self, World world not None, jointgroup=None):
+ self.world = world
+ if jointgroup != None:
+ jointgroup._addjoint(self)
+
+ def setXParam(self, param, value):
+ dJointSetPlane2DXParam(self.jid, param, value)
+
+ def setYParam(self, param, value):
+ dJointSetPlane2DYParam(self.jid, param, value)
+
+ def setAngleParam(self, param, value):
+ dJointSetPlane2DAngleParam(self.jid, param, value)
+
+
+# PRJoint
+cdef class PRJoint(Joint):
+ """Prismatic and Rotoide Joint.
+
+ Constructor::
+
+ PRJoint(world, jointgroup=None)
+ """
+
+ def __cinit__(self, World world not None, jointgroup=None):
+ cdef JointGroup jg
+ cdef dJointGroupID jgid
+
+ jgid = NULL
+ if jointgroup != None:
+ jg = jointgroup
+ jgid = jg.gid
+ self.jid = dJointCreatePR(world.wid, jgid)
+
+ def __init__(self, World world not None, jointgroup=None):
+ self.world = world
+ if jointgroup != None:
+ jointgroup._addjoint(self)
+
+ def getPosition(self):
+ """getPosition()
+
+ Get a PRJoint's linear extension. (i.e. the prismatic's extension)
+ """
+ return dJointGetPRPosition(self.jid)
+
+ def setAnchor(self, pos):
+ """setAnchor(pos)
+
+ Set a PRJoint anchor.
+
+ @param pos: Anchor position
+ @type pos: 3-sequence of floats
+ """
+ dJointSetPRAnchor(self.jid, pos[0], pos[1], pos[2])
+
+ def getAnchor(self):
+ """getAnchor()
+
+ Get a PRJoint anchor.
+ """
+ cdef dVector3 a
+ dJointGetPRAnchor(self.jid, a)
+ return a[0], a[1], a[2]
+
+ def setAxis1(self, axis):
+ """setAxis1(axis)
+
+ Set a PRJoint's prismatic axis.
+
+ @param axis: Axis
+ @type axis: 3-sequence of floats
+ """
+ dJointSetPRAxis1(self.jid, axis[0], axis[1], axis[2])
+
+ def getAxis1(self):
+ """getAxis1()
+
+ Get a PRJoint's prismatic axis.
+ """
+ cdef dVector3 a
+ dJointGetPRAxis1(self.jid, a)
+ return a[0], a[1], a[2]
+
+ def setAxis2(self, axis):
+ """setAxis2(axis)
+
+ Set a PRJoint's rotoide axis.
+
+ @param axis: Axis
+ @type axis: 3-sequence of floats
+ """
+ dJointSetPRAxis2(self.jid, axis[0], axis[1], axis[2])
+
+ def getAxis2(self):
+ """getAxis2()
+
+ Get a PRJoint's rotoide axis.
+ """
+ cdef dVector3 a
+ dJointGetPRAxis2(self.jid, a)
+ return a[0], a[1], a[2]
+
+
+# Geom base class
+cdef class GeomObject:
+ """This is the abstract base class for all geom objects.
+ """
+
+ # The id of the geom object as returned by dCreateXxxx()
+ cdef dGeomID gid
+ # The space in which the geom was placed (or None). This reference
+ # is kept so that the space won't be destroyed while there are still
+ # geoms around that might use it.
+ cdef object space
+ # The body that the geom was attached to (or None).
+ cdef object body
+
+ # A dictionary with user defined attributes
+ cdef object attribs
+
+ cdef object __weakref__
+
+ def __cinit__(self, *a, **kw):
+ self.gid = NULL
+ self.space = None
+ self.body = None
+ self.attribs = {}
+
+ def __init__(self, *a, **kw):
+ raise NotImplementedError(
+ "GeomObject base class can't be used directly")
+
+ def __dealloc__(self):
+ if self.gid != NULL:
+ dGeomDestroy(self.gid)
+ self.gid = NULL
+
+ def __getattr__(self, name):
+ if name in self.attribs:
+ return self.attribs[name]
+ else:
+ raise AttributeError("geom has no attribute '%s'" % name)
+
+ def __setattr__(self, name, val):
+ self.attribs[name] = val
+
+ def __delattr__(self, name):
+ if name in self.attribs:
+ del self.attribs[name]
+ else:
+ raise AttributeError("geom has no attribute '%s'" % name)
+
+ def _id(self):
+ """_id() -> int
+
+ Return the internal id of the geom (dGeomID) as returned by
+ the dCreateXyz() functions.
+
+ This method has to be overwritten in derived methods.
+ """
+ raise NotImplementedError("Bug: The _id() method is not implemented")
+
+ def placeable(self):
+ """placeable() -> bool
+
+ Returns True if the geom object is a placeable geom.
+
+ This method has to be overwritten in derived methods.
+ """
+ return False
+
+ def setBody(self, Body body):
+ """setBody(body)
+
+ Set the body associated with a placeable geom.
+
+ @param body: The Body object or None.
+ @type body: Body
+ """
+
+ if not self.placeable():
+ raise ValueError(
+ "Non-placeable geoms cannot have a body associated to them")
+
+ if body == None:
+ dGeomSetBody(self.gid, NULL)
+ else:
+ dGeomSetBody(self.gid, body.bid)
+ self.body = body
+
+ def getBody(self):
+ """getBody() -> Body
+
+ Get the body associated with this geom.
+ """
+ if not self.placeable():
+ return environment
+
+ return self.body
+
+ def setPosition(self, pos):
+ """setPosition(pos)
+
+ Set the position of the geom. If the geom is attached to a body,
+ the body's position will also be changed.
+
+ @param pos: Position
+ @type pos: 3-sequence of floats
+ """
+ if not self.placeable():
+ raise ValueError("Cannot set a position on non-placeable geoms")
+ dGeomSetPosition(self.gid, pos[0], pos[1], pos[2])
+
+ def getPosition(self):
+ """getPosition() -> 3-tuple
+
+ Get the current position of the geom. If the geom is attached to
+ a body the returned value is the body's position.
+ """
+ if not self.placeable():
+ raise ValueError("Non-placeable geoms do not have a position")
+
+ cdef dReal* p
+ p = <dReal*>dGeomGetPosition(self.gid)
+ return p[0], p[1], p[2]
+
+ def setRotation(self, R):
+ """setRotation(R)
+
+ Set the orientation of the geom. If the geom is attached to a body,
+ the body's orientation will also be changed.
+
+ @param R: Rotation matrix
+ @type R: 9-sequence of floats
+ """
+ if not self.placeable():
+ raise ValueError("Cannot set a rotation on non-placeable geoms")
+
+ cdef dMatrix3 m
+ m[0] = R[0]
+ m[1] = R[1]
+ m[2] = R[2]
+ m[3] = 0
+ m[4] = R[3]
+ m[5] = R[4]
+ m[6] = R[5]
+ m[7] = 0
+ m[8] = R[6]
+ m[9] = R[7]
+ m[10] = R[8]
+ m[11] = 0
+ dGeomSetRotation(self.gid, m)
+
+ def getRotation(self):
+ """getRotation() -> 9-tuple
+
+ Get the current orientation of the geom. If the geom is attached to
+ a body the returned value is the body's orientation.
+ """
+ if not self.placeable():
+ raise ValueError("Non-placeable geoms do not have a rotation")
+
+ cdef dReal* m
+ m = <dReal*>dGeomGetRotation(self.gid)
+ return [m[0], m[1], m[2], m[4], m[5], m[6], m[8], m[9], m[10]]
+
+ def getQuaternion(self):
+ """getQuaternion() -> (w,x,y,z)
+
+ Get the current orientation of the geom. If the geom is attached to
+ a body the returned value is the body's orientation.
+ """
+ if not self.placeable():
+ raise ValueError("Non-placeable geoms do not have an orientation")
+
+ cdef dQuaternion q
+ dGeomGetQuaternion(self.gid, q)
+ return q[0], q[1], q[2], q[3]
+
+ def setQuaternion(self, q):
+ """setQuaternion(q)
+
+ Set the orientation of the geom. If the geom is attached to a body,
+ the body's orientation will also be changed.
+
+ @param q: Quaternion (w,x,y,z)
+ @type q: 4-sequence of floats
+ """
+ if not self.placeable():
+ raise ValueError("Cannot set a quaternion on non-placeable geoms")
+
+ cdef dQuaternion cq
+ cq[0] = q[0]
+ cq[1] = q[1]
+ cq[2] = q[2]
+ cq[3] = q[3]
+ dGeomSetQuaternion(self.gid, cq)
+
+ def setOffsetPosition(self, pos):
+ """setOffsetPosition(pos)
+
+ Set the offset position of the geom. The geom must be attached to a
+ body. If the geom did not have an offset, it is automatically created.
+ This sets up an additional (local) transformation for the geom, since
+ geoms attached to a body share their global position and rotation.
+
+ @param pos: Position
+ @type pos: 3-sequence of floats
+ """
+ if self.body == None:
+ raise ValueError("Cannot set an offset position on a geom before "
+ "calling setBody")
+ dGeomSetOffsetPosition(self.gid, pos[0], pos[1], pos[2])
+
+ def getOffsetPosition(self):
+ """getOffsetPosition() -> 3-tuple
+
+ Get the offset position of the geom.
+ """
+ cdef dReal* p
+ p = <dReal*>dGeomGetOffsetPosition(self.gid)
+ return (p[0],p[1],p[2])
+
+ def setOffsetRotation(self, R):
+ """setOffsetRotation(R)
+
+ Set the offset rotation of the geom. The geom must be attached to a
+ body. If the geom did not have an offset, it is automatically created.
+ This sets up an additional (local) transformation for the geom, since
+ geoms attached to a body share their global position and rotation.
+
+ @param R: Rotation matrix
+ @type R: 9-sequence of floats
+ """
+ if self.body == None:
+ raise ValueError("Cannot set an offset rotation on a geom before "
+ "calling setBody")
+
+ cdef dMatrix3 m
+ m[0] = R[0]
+ m[1] = R[1]
+ m[2] = R[2]
+ m[3] = 0
+ m[4] = R[3]
+ m[5] = R[4]
+ m[6] = R[5]
+ m[7] = 0
+ m[8] = R[6]
+ m[9] = R[7]
+ m[10] = R[8]
+ m[11] = 0
+ dGeomSetOffsetRotation(self.gid, m)
+
+ def getOffsetRotation(self):
+ """getOffsetRotation() -> 9-tuple
+
+ Get the offset rotation of the geom.
+ """
+ cdef dReal* m
+ m = <dReal*>dGeomGetOffsetRotation(self.gid)
+ return [m[0], m[1], m[2], m[4], m[5], m[6], m[8], m[9], m[10]]
+
+ def clearOffset(self):
+ """clearOffset()
+
+ Disable the offset transform of the geom.
+ """
+ dGeomClearOffset(self.gid)
+
+ def getAABB(self):
+ """getAABB() -> 6-tuple
+
+ Return an axis aligned bounding box that surrounds the geom.
+ The return value is a 6-tuple (minx, maxx, miny, maxy, minz, maxz).
+ """
+ cdef dReal aabb[6]
+
+ dGeomGetAABB(self.gid, aabb)
+ return aabb[0], aabb[1], aabb[2], aabb[3], aabb[4], aabb[5]
+
+ def isSpace(self):
+ """isSpace() -> bool
+
+ Return 1 if the given geom is a space, or 0 if not."""
+ return dGeomIsSpace(self.gid)
+
+ def getSpace(self):
+ """getSpace() -> Space
+
+ Return the space that the given geometry is contained in,
+ or return None if it is not contained in any space."""
+ return self.space
+
+ def setCollideBits(self, bits):
+ """setCollideBits(bits)
+
+ Set the "collide" bitfields for this geom.
+
+ @param bits: Collide bit field
+ @type bits: int/long
+ """
+ dGeomSetCollideBits(self.gid, long(bits))
+
+ def setCategoryBits(self, bits):
+ """setCategoryBits(bits)
+
+ Set the "category" bitfields for this geom.
+
+ @param bits: Category bit field
+ @type bits: int/long
+ """
+ dGeomSetCategoryBits(self.gid, long(bits))
+
+ def getCollideBits(self):
+ """getCollideBits() -> long
+
+ Return the "collide" bitfields for this geom.
+ """
+ return dGeomGetCollideBits(self.gid)
+
+ def getCategoryBits(self):
+ """getCategoryBits() -> long
+
+ Return the "category" bitfields for this geom.
+ """
+ return dGeomGetCategoryBits(self.gid)
+
+ def enable(self):
+ """enable()
+
+ Enable the geom."""
+ dGeomEnable(self.gid)
+
+ def disable(self):
+ """disable()
+
+ Disable the geom."""
+ dGeomDisable(self.gid)
+
+ def isEnabled(self):
+ """isEnabled() -> bool
+
+ Return True if the geom is enabled."""
+ return dGeomIsEnabled(self.gid)
+
+
+# _SpaceIterator
+class _SpaceIterator:
+ """Iterates over the geoms inside a Space.
+ """
+
+ def __init__(self, space):
+ self.space = space
+ self.idx = 0
+
+ def __iter__(self):
+ return self
+
+ def next(self):
+ if self.idx >= self.space.getNumGeoms():
+ raise StopIteration
+ else:
+ res = self.space.getGeom(self.idx)
+ self.idx = self.idx + 1
+ return res
+
+
+# SpaceBase
+cdef class SpaceBase(GeomObject):
+ """Space class (container for geometry objects).
+
+ A Space object is a container for geometry objects which are used
+ to do collision detection.
+ The space does high level collision culling, which means that it
+ can identify which pairs of geometry objects are potentially
+ touching.
+
+ This Space class can be used for both, a SimpleSpace and a HashSpace
+ (see ODE documentation).
+
+ >>> space = Space(type=0) # Create a SimpleSpace
+ >>> space = Space(type=1) # Create a HashSpace
+ """
+
+ # The id of the space. Actually this is a copy of the value in self.gid
+ # (as the Space is derived from GeomObject) which can be used without
+ # casting whenever a *space* id is required.
+ cdef dSpaceID sid
+
+ # Dictionary with Geomobjects. Key is the ID (geom._id()) and the value
+ # is the geom object (Python wrapper). This is used in collide_callback()
+# cdef object geom_dict
+
+ def __cinit__(self, *a, **kw):
+ pass
+
+ def __init__(self, *a, **kw):
+ raise NotImplementedError("The SpaceBase class can't be used directly")
+
+ def __dealloc__(self):
+ if self.gid != NULL:
+ dSpaceDestroy(self.sid)
+ self.sid = NULL
+ self.gid = NULL
+
+# def _addgeom(self, geom):
+# """Insert the geom object into the dictionary (internal method).
+#
+# This method has to called in the constructor of a geom object.
+# """
+# self.geom_dict[geom._id()]=geom
+
+# def _id2geom(self, id):
+# """Get the Python wrapper that corresponds to an ID.
+#
+# The ID is the integer value, as returned by geom._id().
+# If the ID is unknown then None is returned.
+# """
+# if id in self.geom_dict:
+# return self.geom_dict[id]
+# else:
+# return None
+
+ def _id(self):
+ cdef size_t id
+ id = <size_t>self.sid
+ return id
+
+ def __len__(self):
+ return self.getNumGeoms()
+
+ def __iter__(self):
+ return _SpaceIterator(self)
+
+ def add(self, GeomObject geom):
+ """add(geom)
+
+ Add a geom to a space. This does nothing if the geom is
+ already in the space.
+
+ @param geom: Geom object to add
+ @type geom: GeomObject
+ """
+
+ dSpaceAdd(self.sid, geom.gid)
+
+ def remove(self, GeomObject geom):
+ """remove(geom)
+
+ Remove a geom from a space.
+
+ @param geom: Geom object to remove
+ @type geom: GeomObject
+ """
+ dSpaceRemove(self.sid, geom.gid)
+
+ def query(self, GeomObject geom):
+ """query(geom) -> bool
+
+ Return True if the given geom is in the space.
+
+ @param geom: Geom object to check
+ @type geom: GeomObject
+ """
+ return dSpaceQuery(self.sid, geom.gid)
+
+ def getNumGeoms(self):
+ """getNumGeoms() -> int
+
+ Return the number of geoms contained within the space.
+ """
+ return dSpaceGetNumGeoms(self.sid)
+
+ def getGeom(self, int idx):
+ """getGeom(idx) -> GeomObject
+
+ Return the geom with the given index contained within the space.
+
+ @param idx: Geom index (0,1,...,getNumGeoms()-1)
+ @type idx: int
+ """
+ cdef dGeomID gid
+
+ # Check the index
+ if idx < 0 or idx >= dSpaceGetNumGeoms(self.sid):
+ raise IndexError("geom index out of range")
+
+ gid = dSpaceGetGeom(self.sid, idx)
+ if <size_t>gid not in _geom_c2py_lut:
+ raise RuntimeError(
+ "geom id cannot be translated to a Python object")
+
+ return _geom_c2py_lut[<size_t>gid]
+
+ def collide(self, arg, callback):
+ """collide(arg, callback)
+
+ Call a callback function one or more times, for all
+ potentially intersecting objects in the space. The callback
+ function takes 3 arguments:
+
+ def NearCallback(arg, geom1, geom2):
+
+ The arg parameter is just passed on to the callback function.
+ Its meaning is user defined. The geom1 and geom2 arguments are
+ the geometry objects that may be near each other. The callback
+ function can call the function collide() (not the Space
+ method) on geom1 and geom2, perhaps first determining
+ whether to collide them at all based on other information.
+
+ @param arg: A user argument that is passed to the callback function
+ @param callback: Callback function
+ @type callback: callable
+ """
+
+ cdef void* data
+ cdef object tup
+ tup = (callback, arg)
+ data = <void*>tup
+ dSpaceCollide(self.sid, data, collide_callback)
+
+
+# Callback function for the dSpaceCollide() call in the Space.collide() method
+# The data parameter is a tuple (Python-Callback, Arguments).
+# The function calls a Python callback function with 3 arguments:
+# def callback(UserArg, Geom1, Geom2)
+# Geom1 and Geom2 are instances of GeomXyz classes.
+cdef void collide_callback(void* data, dGeomID o1, dGeomID o2):
+ cdef object tup
+# cdef Space space
+ cdef size_t id1, id2
+
+# if (dGeomGetBody(o1)==dGeomGetBody(o2)):
+# return
+
+ tup = <object>data
+ callback, arg = tup
+ id1 = <size_t>o1
+ id2 = <size_t>o2
+ g1 = _geom_c2py_lut[id1]
+ g2 = _geom_c2py_lut[id2]
+ callback(arg, g1, g2)
+
+
+# SimpleSpace
+cdef class SimpleSpace(SpaceBase):
+ """Simple space.
+
+ This does not do any collision culling - it simply checks every
+ possible pair of geoms for intersection, and reports the pairs
+ whose AABBs overlap. The time required to do intersection testing
+ for n objects is O(n**2). This should not be used for large numbers
+ of objects, but it can be the preferred algorithm for a small
+ number of objects. This is also useful for debugging potential
+ problems with the collision system.
+ """
+
+ def __cinit__(self, space=None):
+ cdef SpaceBase sp
+ cdef dSpaceID parentid
+
+ parentid = NULL
+ if space != None:
+ sp = space
+ parentid = sp.sid
+
+ self.sid = dSimpleSpaceCreate(parentid)
+
+ # Copy the ID
+ self.gid = <dGeomID>self.sid
+
+ dSpaceSetCleanup(self.sid, 0)
+ _geom_c2py_lut[<size_t>self.sid] = self
+
+ def __init__(self, space=None):
+ pass
+
+# HashSpace
+cdef class HashSpace(SpaceBase):
+ """Multi-resolution hash table space.
+
+ This uses an internal data structure that records how each geom
+ overlaps cells in one of several three dimensional grids. Each
+ grid has cubical cells of side lengths 2**i, where i is an integer
+ that ranges from a minimum to a maximum value. The time required
+ to do intersection testing for n objects is O(n) (as long as those
+ objects are not clustered together too closely), as each object
+ can be quickly paired with the objects around it.
+ """
+
+ def __cinit__(self, space=None):
+ cdef SpaceBase sp
+ cdef dSpaceID parentid
+
+ parentid = NULL
+ if space != None:
+ sp = space
+ parentid = sp.sid
+
+ self.sid = dHashSpaceCreate(parentid)
+
+ # Copy the ID
+ self.gid = <dGeomID>self.sid
+
+ dSpaceSetCleanup(self.sid, 0)
+ _geom_c2py_lut[<size_t>self.sid] = self
+
+ def __init__(self, space=None):
+ pass
+
+ def setLevels(self, int minlevel, int maxlevel):
+ """setLevels(minlevel, maxlevel)
+
+ Sets the size of the smallest and largest cell used in the
+ hash table. The actual size will be 2^minlevel and 2^maxlevel
+ respectively.
+ """
+
+ if minlevel > maxlevel:
+ raise ValueError(
+ "minlevel (%d) must be less than or equal to maxlevel (%d)" %
+ (minlevel, maxlevel))
+
+ dHashSpaceSetLevels(self.sid, minlevel, maxlevel)
+
+ def getLevels(self):
+ """getLevels() -> (minlevel, maxlevel)
+
+ Gets the size of the smallest and largest cell used in the
+ hash table. The actual size is 2^minlevel and 2^maxlevel
+ respectively.
+ """
+
+ cdef int minlevel
+ cdef int maxlevel
+ dHashSpaceGetLevels(self.sid, &minlevel, &maxlevel)
+ return minlevel, maxlevel
+
+
+# QuadTreeSpace
+cdef class QuadTreeSpace(SpaceBase):
+ """Quadtree space.
+
+ This uses a pre-allocated hierarchical grid-based AABB tree to
+ quickly cull collision checks. It's exceptionally quick for large
+ amounts of objects in landscape-shaped worlds. The amount of
+ memory used is 4**depth * 32 bytes.
+
+ Currently getGeom() is not implemented for the quadtree space.
+ """
+
+ def __cinit__(self, center, extents, depth, space=None):
+ cdef SpaceBase sp
+ cdef dSpaceID parentid
+ cdef dVector3 c
+ cdef dVector3 e
+
+ parentid = NULL
+ if space != None:
+ sp = space
+ parentid = sp.sid
+
+ c[0] = center[0]
+ c[1] = center[1]
+ c[2] = center[2]
+ e[0] = extents[0]
+ e[1] = extents[1]
+ e[2] = extents[2]
+ self.sid = dQuadTreeSpaceCreate(parentid, c, e, depth)
+
+ # Copy the ID
+ self.gid = <dGeomID>self.sid
+
+ dSpaceSetCleanup(self.sid, 0)
+ _geom_c2py_lut[<size_t>self.sid] = self
+
+ def __init__(self, center, extents, depth, space=None):
+ pass
+
+
+def Space(space_type=0):
+ """Space factory function.
+
+ Depending on the type argument this function either returns a
+ SimpleSpace (space_type=0) or a HashSpace (space_type=1).
+
+ This function is provided to remain compatible with previous
+ versions of PyODE where there was only one Space class.
+
+ >>> space = Space(space_type=0) # Create a SimpleSpace
+ >>> space = Space(space_type=1) # Create a HashSpace
+ """
+ if space_type == 0:
+ return SimpleSpace()
+ elif space_type == 1:
+ return HashSpace()
+ else:
+ raise ValueError("Unknown space type (%d)" % space_type)
+
+
+# GeomSphere
+cdef class GeomSphere(GeomObject):
+ """Sphere geometry.
+
+ This class represents a sphere centered at the origin.
+
+ Constructor::
+
+ GeomSphere(space=None, radius=1.0)
+ """
+
+ def __cinit__(self, space=None, radius=1.0):
+ cdef SpaceBase sp
+ cdef dSpaceID sid
+
+ sid = NULL
+ if space != None:
+ sp = space
+ sid = sp.sid
+ self.gid = dCreateSphere(sid, radius)
+# if space != None:
+# space._addgeom(self)
+
+ _geom_c2py_lut[<size_t>self.gid] = self
+
+ def __init__(self, space=None, radius=1.0):
+ self.space = space
+ self.body = None
+
+ def placeable(self):
+ return True
+
+ def _id(self):
+ cdef size_t id
+ id = <size_t>self.gid
+ return id
+
+ def setRadius(self, radius):
+ """setRadius(radius)
+
+ Set the radius of the sphere.
+
+ @param radius: New radius
+ @type radius: float
+ """
+ dGeomSphereSetRadius(self.gid, radius)
+
+ def getRadius(self):
+ """getRadius() -> float
+
+ Return the radius of the sphere.
+ """
+ return dGeomSphereGetRadius(self.gid)
+
+ def pointDepth(self, p):
+ """pointDepth(p) -> float
+
+ Return the depth of the point p in the sphere. Points inside
+ the geom will have positive depth, points outside it will have
+ negative depth, and points on the surface will have zero
+ depth.
+
+ @param p: Point
+ @type p: 3-sequence of floats
+ """
+ return dGeomSpherePointDepth(self.gid, p[0], p[1], p[2])
+
+
+# GeomBox
+cdef class GeomBox(GeomObject):
+ """Box geometry.
+
+ This class represents a box centered at the origin.
+
+ Constructor::
+
+ GeomBox(space=None, lengths=(1.0, 1.0, 1.0))
+ """
+
+ def __cinit__(self, space=None, lengths=(1.0, 1.0, 1.0)):
+ cdef SpaceBase sp
+ cdef dSpaceID sid
+
+ sid = NULL
+ if space != None:
+ sp = space
+ sid = sp.sid
+ self.gid = dCreateBox(sid, lengths[0], lengths[1], lengths[2])
+# if space != None:
+# space._addgeom(self)
+
+ _geom_c2py_lut[<size_t>self.gid] = self
+
+ def __init__(self, space=None, lengths=(1.0, 1.0, 1.0)):
+ self.space = space
+ self.body = None
+
+ def placeable(self):
+ return True
+
+ def _id(self):
+ cdef size_t id
+ id = <size_t>self.gid
+ return id
+
+ def setLengths(self, lengths):
+ dGeomBoxSetLengths(self.gid, lengths[0], lengths[1], lengths[2])
+
+ def getLengths(self):
+ cdef dVector3 res
+ dGeomBoxGetLengths(self.gid, res)
+ return res[0], res[1], res[2]
+
+ def pointDepth(self, p):
+ """pointDepth(p) -> float
+
+ Return the depth of the point p in the box. Points inside the
+ geom will have positive depth, points outside it will have
+ negative depth, and points on the surface will have zero
+ depth.
+
+ @param p: Point
+ @type p: 3-sequence of floats
+ """
+ return dGeomBoxPointDepth(self.gid, p[0], p[1], p[2])
+
+
+# GeomPlane
+cdef class GeomPlane(GeomObject):
+ """Plane geometry.
+
+ This class represents an infinite plane. The plane equation is:
+ n.x*x + n.y*y + n.z*z = dist
+
+ This object can't be attached to a body.
+ If you call getBody() on this object it always returns ode.environment.
+
+ Constructor::
+
+ GeomPlane(space=None, normal=(0,0,1), dist=0)
+
+ """
+
+ def __cinit__(self, space=None, normal=(0, 0, 1), dist=0):
+ cdef SpaceBase sp
+ cdef dSpaceID sid
+
+ sid = NULL
+ if space != None:
+ sp = space
+ sid = sp.sid
+ self.gid = dCreatePlane(sid, normal[0], normal[1], normal[2], dist)
+# if space != None:
+# space._addgeom(self)
+
+ _geom_c2py_lut[<size_t>self.gid] = self
+
+ def __init__(self, space=None, normal=(0, 0, 1), dist=0):
+ self.space = space
+
+ def _id(self):
+ cdef size_t id
+ id = <size_t>self.gid
+ return id
+
+ def setParams(self, normal, dist):
+ dGeomPlaneSetParams(self.gid, normal[0], normal[1], normal[2], dist)
+
+ def getParams(self):
+ cdef dVector4 res
+ dGeomPlaneGetParams(self.gid, res)
+ return ((res[0], res[1], res[2]), res[3])
+
+ def pointDepth(self, p):
+ """pointDepth(p) -> float
+
+ Return the depth of the point p in the plane. Points inside the
+ geom will have positive depth, points outside it will have
+ negative depth, and points on the surface will have zero
+ depth.
+
+ @param p: Point
+ @type p: 3-sequence of floats
+ """
+ return dGeomPlanePointDepth(self.gid, p[0], p[1], p[2])
+
+
+# GeomCapsule
+cdef class GeomCapsule(GeomObject):
+ """Capped cylinder geometry.
+
+ This class represents a capped cylinder aligned along the local Z axis
+ and centered at the origin.
+
+ Constructor::
+
+ GeomCapsule(space=None, radius=0.5, length=1.0)
+
+ The length parameter does not include the caps.
+ """
+
+ def __cinit__(self, space=None, radius=0.5, length=1.0):
+ cdef SpaceBase sp
+ cdef dSpaceID sid
+
+ sid = NULL
+ if space != None:
+ sp = space
+ sid = sp.sid
+ self.gid = dCreateCapsule(sid, radius, length)
+# if space != None:
+# space._addgeom(self)
+
+ _geom_c2py_lut[<size_t>self.gid] = self
+
+ def __init__(self, space=None, radius=0.5, length=1.0):
+ self.space = space
+ self.body = None
+
+ def placeable(self):
+ return True
+
+ def _id(self):
+ cdef size_t id
+ id = <size_t>self.gid
+ return id
+
+ def setParams(self, radius, length):
+ dGeomCapsuleSetParams(self.gid, radius, length)
+
+ def getParams(self):
+ cdef dReal radius, length
+ dGeomCapsuleGetParams(self.gid, &radius, &length)
+ return radius, length
+
+ def pointDepth(self, p):
+ """pointDepth(p) -> float
+
+ Return the depth of the point p in the cylinder. Points inside the
+ geom will have positive depth, points outside it will have
+ negative depth, and points on the surface will have zero
+ depth.
+
+ @param p: Point
+ @type p: 3-sequence of floats
+ """
+ return dGeomCapsulePointDepth(self.gid, p[0], p[1], p[2])
+
+GeomCCylinder = GeomCapsule # backwards compatibility
+
+
+# GeomCylinder
+cdef class GeomCylinder(GeomObject):
+ """Plain cylinder geometry.
+
+ This class represents an uncapped cylinder aligned along the local Z axis
+ and centered at the origin.
+
+ Constructor::
+
+ GeomCylinder(space=None, radius=0.5, length=1.0)
+ """
+
+ def __cinit__(self, space=None, radius=0.5, length=1.0):
+ cdef SpaceBase sp
+ cdef dSpaceID sid
+
+ sid = NULL
+ if space != None:
+ sp = space
+ sid = sp.sid
+ self.gid = dCreateCylinder(sid, radius, length)
+# if space != None:
+# space._addgeom(self)
+
+ _geom_c2py_lut[<size_t>self.gid] = self
+
+ def __init__(self, space=None, radius=0.5, length=1.0):
+ self.space = space
+ self.body = None
+
+ def placeable(self):
+ return True
+
+ def _id(self):
+ cdef size_t id
+ id = <size_t>self.gid
+ return id
+
+ def setParams(self, radius, length):
+ dGeomCylinderSetParams(self.gid, radius, length)
+
+ def getParams(self):
+ cdef dReal radius, length
+ dGeomCylinderGetParams(self.gid, &radius, &length)
+ return radius, length
+
+ ## dGeomCylinderPointDepth not implemented upstream in ODE 0.7
+
+
+# GeomRay
+cdef class GeomRay(GeomObject):
+ """Ray object.
+
+ A ray is different from all the other geom classes in that it does
+ not represent a solid object. It is an infinitely thin line that
+ starts from the geom's position and extends in the direction of
+ the geom's local Z-axis.
+
+ Constructor::
+
+ GeomRay(space=None, rlen=1.0)
+
+ """
+
+ def __cinit__(self, space=None, rlen=1.0):
+ cdef SpaceBase sp
+ cdef dSpaceID sid
+
+ sid = NULL
+ if space != None:
+ sp = space
+ sid = sp.sid
+ self.gid = dCreateRay(sid, rlen)
+# if space != None:
+# space._addgeom(self)
+
+ _geom_c2py_lut[<size_t>self.gid] = self
+
+ def __init__(self, space=None, rlen=1.0):
+ self.space = space
+ self.body = None
+
+ def _id(self):
+ cdef size_t id
+ id = <size_t>self.gid
+ return id
+
+ def placeable(self):
+ return True
+
+ def setLength(self, rlen):
+ '''setLength(rlen)
+
+ Set length of the ray.
+
+ @param rlen: length of the ray
+ @type rlen: float'''
+ dGeomRaySetLength(self.gid, rlen)
+
+ def getLength(self):
+ '''getLength() -> length
+
+ Get the length of the ray.
+
+ @returns: length of the ray (float)'''
+ return dGeomRayGetLength(self.gid)
+
+ def set(self, p, u):
+ '''set(p, u)
+
+ Set the position and rotation of a ray.
+
+ @param p: position
+ @type p: 3-sequence of floats
+ @param u: rotation
+ @type u: 3-sequence of floats'''
+ dGeomRaySet(self.gid, p[0], p[1], p[2], u[0], u[1], u[2])
+
+ def get(self):
+ '''get() -> ((p[0], p[1], p[2]), (u[0], u[1], u[2]))
+
+ Return the position and rotation as a pair of
+ tuples.
+
+ @returns: position and rotation'''
+ cdef dVector3 start
+ cdef dVector3 dir
+ dGeomRayGet(self.gid, start, dir)
+ return (start[0], start[1], start[2]), (dir[0], dir[1], dir[2])
+
+
+# GeomTransform
+cdef class GeomTransform(GeomObject):
+ """GeomTransform.
+
+ A geometry transform "T" is a geom that encapsulates another geom
+ "E", allowing E to be positioned and rotated arbitrarily with
+ respect to its point of reference.
+
+ Constructor::
+
+ GeomTransform(space=None)
+ """
+
+ cdef object geom
+
+ def __cinit__(self, space=None):
+ cdef SpaceBase sp
+ cdef dSpaceID sid
+
+ sid = NULL
+ if space != None:
+ sp = space
+ sid = sp.sid
+ self.gid = dCreateGeomTransform(sid)
+ # Set cleanup mode to 0 as a contained geom will be deleted
+ # by its Python wrapper class
+ dGeomTransformSetCleanup(self.gid, 0)
+# if space != None:
+# space._addgeom(self)
+
+ _geom_c2py_lut[<size_t>self.gid] = self
+
+ def __init__(self, space=None):
+ self.space = space
+ self.body = None
+ self.geom = None
+
+ self.attribs = {}
+
+ def placeable(self):
+ return True
+
+ def _id(self):
+ cdef size_t id
+ id = <size_t>self.gid
+ return id
+
+ def setGeom(self, GeomObject geom not None):
+ """setGeom(geom)
+
+ Set the geom that the geometry transform encapsulates.
+ A ValueError exception is thrown if a) the geom is not placeable,
+ b) the geom was already inserted into a space or c) the geom is
+ already associated with a body.
+
+ @param geom: Geom object to encapsulate
+ @type geom: GeomObject
+ """
+ cdef size_t id
+
+ if not geom.placeable():
+ raise ValueError(
+ "Only placeable geoms can be encapsulated by a GeomTransform")
+ if dGeomGetSpace(geom.gid) != <dSpaceID>0:
+ raise ValueError(
+ "The encapsulated geom was already inserted into a space")
+ if dGeomGetBody(geom.gid) != <dBodyID>0:
+ raise ValueError(
+ "The encapsulated geom is already associated with a body")
+
+ id = geom._id()
+ dGeomTransformSetGeom(self.gid, <dGeomID>id)
+ self.geom = geom
+
+ def getGeom(self):
+ """getGeom() -> GeomObject
+
+ Get the geom that the geometry transform encapsulates.
+ """
+ return self.geom
+
+ def setInfo(self, int mode):
+ """setInfo(mode)
+
+ Set the "information" mode of the geometry transform.
+
+ With mode 0, when a transform object is collided with another
+ object, the geom field of the ContactGeom structure is set to the
+ geom that is encapsulated by the transform object.
+
+ With mode 1, the geom field of the ContactGeom structure is set
+ to the transform object itself.
+
+ @param mode: Information mode (0 or 1)
+ @type mode: int
+ """
+ if mode < 0 or mode > 1:
+ raise ValueError(
+ "Invalid information mode (%d). Must be either 0 or 1." % mode)
+ dGeomTransformSetInfo(self.gid, mode)
+
+ def getInfo(self):
+ """getInfo() -> int
+
+ Get the "information" mode of the geometry transform (0 or 1).
+
+ With mode 0, when a transform object is collided with another
+ object, the geom field of the ContactGeom structure is set to the
+ geom that is encapsulated by the transform object.
+
+ With mode 1, the geom field of the ContactGeom structure is set
+ to the transform object itself.
+ """
+ return dGeomTransformGetInfo(self.gid)
+
+######################################################################
+
+
+cdef class TriMeshData:
+ """This class stores the mesh data.
+ """
+
+ cdef dTriMeshDataID tmdid
+ cdef dReal* vertex_buffer
+ cdef int* face_buffer
+
+ def __cinit__(self):
+ self.tmdid = dGeomTriMeshDataCreate()
+ self.vertex_buffer = NULL
+ self.face_buffer = NULL
+
+ def __dealloc__(self):
+ if self.tmdid != NULL:
+ dGeomTriMeshDataDestroy(self.tmdid)
+ if self.vertex_buffer != NULL:
+ free(self.vertex_buffer)
+ if self.face_buffer != NULL:
+ free(self.face_buffer)
+
+ def build(self, verts, faces):
+ """build(verts, faces)
+
+ @param verts: Vertices
+ @type verts: Sequence of 3-sequences of floats
+ @param faces: Face definitions (three indices per face)
+ @type faces: Sequence of 3-sequences of ints
+ """
+ cdef int numverts
+ cdef int numfaces
+ cdef dReal* vp
+ cdef int* fp
+ cdef int a, b, c
+
+ numverts = len(verts)
+ numfaces = len(faces)
+ # Allocate the vertex and face buffer
+ self.vertex_buffer = <dReal*>malloc(numverts * 4 * sizeof(dReal))
+ self.face_buffer = <int*>malloc(numfaces * 3 * sizeof(int))
+
+ # Fill the vertex buffer
+ vp = self.vertex_buffer
+ for v in verts:
+ vp[0] = v[0]
+ vp[1] = v[1]
+ vp[2] = v[2]
+ vp[3] = 0
+ vp = vp + 4
+
+ # Fill the face buffer
+ fp = self.face_buffer
+ for f in faces:
+ a = f[0]
+ b = f[1]
+ c = f[2]
+ if (a < 0 or b < 0 or c < 0 or a >= numverts or b >= numverts or c >= numverts):
+ raise ValueError("Vertex index out of range")
+ fp[0] = a
+ fp[1] = b
+ fp[2] = c
+ fp = fp + 3
+
+ # Pass the data to ODE
+ dGeomTriMeshDataBuildSimple(self.tmdid, self.vertex_buffer, numverts,
+ self.face_buffer, numfaces * 3)
+
+######################################################################
+
+
+# GeomTriMesh
+cdef class GeomTriMesh(GeomObject):
+ """TriMesh object.
+
+ To construct the trimesh geom you need a TriMeshData object that
+ stores the actual mesh. This object has to be passed as first
+ argument to the constructor.
+
+ Constructor::
+
+ GeomTriMesh(data, space=None)
+ """
+
+ # Keep a reference to the data
+ cdef TriMeshData data
+
+ def __cinit__(self, TriMeshData data not None, space=None):
+ cdef SpaceBase sp
+ cdef dSpaceID sid
+
+ self.data = data
+
+ sid = NULL
+ if space != None:
+ sp = space
+ sid = sp.sid
+ self.gid = dCreateTriMesh(sid, data.tmdid, NULL, NULL, NULL)
+
+ _geom_c2py_lut[<size_t>self.gid] = self
+
+ def __init__(self, TriMeshData data not None, space=None):
+ self.space = space
+ self.body = None
+
+ def placeable(self):
+ return True
+
+ def _id(self):
+ cdef size_t id
+ id = <size_t>self.gid
+ return id
+
+ def clearTCCache(self):
+ """clearTCCache()
+
+ Clears the internal temporal coherence caches.
+ """
+ dGeomTriMeshClearTCCache(self.gid)
+
+ def getTriangle(self, int idx):
+ """getTriangle(idx) -> (v0, v1, v2)
+
+ @param idx: Triangle index
+ @type idx: int
+ """
+
+ cdef dVector3 v0, v1, v2
+ cdef dVector3* vp0
+ cdef dVector3* vp1
+ cdef dVector3* vp2
+
+ vp0 = <dVector3*>v0
+ vp1 = <dVector3*>v1
+ vp2 = <dVector3*>v2
+
+ dGeomTriMeshGetTriangle(self.gid, idx, vp0, vp1, vp2)
+ return ((v0[0], v0[1], v0[2]),
+ (v1[0], v1[1], v1[2]),
+ (v2[0], v2[1], v2[2]))
+
+ def getTriangleCount(self):
+ """getTriangleCount() -> n
+
+ Returns the number of triangles in the TriMesh."""
+
+ return dGeomTriMeshGetTriangleCount(self.gid)
+
+######################################################################
+
+
+def collide(geom1, geom2):
+ """collide(geom1, geom2) -> contacts
+
+ Generate contact information for two objects.
+
+ Given two geometry objects that potentially touch (geom1 and geom2),
+ generate contact information for them. Internally, this just calls
+ the correct class-specific collision functions for geom1 and geom2.
+
+ [flags specifies how contacts should be generated if the objects
+ touch. Currently the lower 16 bits of flags specifies the maximum
+ number of contact points to generate. If this number is zero, this
+ function just pretends that it is one - in other words you can not
+ ask for zero contacts. All other bits in flags must be zero. In
+ the future the other bits may be used to select other contact
+ generation strategies.]
+
+ If the objects touch, this returns a list of Contact objects,
+ otherwise it returns an empty list.
+
+ @param geom1: First Geom
+ @type geom1: GeomObject
+ @param geom2: Second Geom
+ @type geom2: GeomObject
+ @returns: Returns a list of Contact objects.
+ """
+
+ cdef dContactGeom c[150]
+ cdef size_t id1
+ cdef size_t id2
+ cdef int i, n
+ cdef Contact cont
+
+ id1 = geom1._id()
+ id2 = geom2._id()
+
+ n = dCollide(<dGeomID>id1, <dGeomID>id2, 150, c, sizeof(dContactGeom))
+ res = []
+ i = 0
+ while i < n:
+ cont = Contact()
+ cont._contact.geom = c[i]
+ res.append(cont)
+ i = i + 1
+
+ return res
+
+
+def collide2(geom1, geom2, arg, callback):
+ """collide2(geom1, geom2, arg, callback)
+
+ Calls the callback for all potentially intersecting pairs that contain
+ one geom from geom1 and one geom from geom2.
+
+ @param geom1: First Geom
+ @type geom1: GeomObject
+ @param geom2: Second Geom
+ @type geom2: GeomObject
+ @param arg: A user argument that is passed to the callback function
+ @param callback: Callback function
+ @type callback: callable
+ """
+ cdef void* data
+ cdef object tup
+ cdef size_t id1
+ cdef size_t id2
+
+ id1 = geom1._id()
+ id2 = geom2._id()
+
+ tup = (callback, arg)
+ data = <void*>tup
+ # collide_callback is defined in space.pyx
+ dSpaceCollide2(<dGeomID>id1, <dGeomID>id2, data, collide_callback)
+
+
+def areConnected(Body body1, Body body2):
+ """areConnected(body1, body2) -> bool
+
+ Return True if the two bodies are connected together by a joint,
+ otherwise return False.
+
+ @param body1: First body
+ @type body1: Body
+ @param body2: Second body
+ @type body2: Body
+ @returns: True if the bodies are connected
+ """
+
+ if body1 is environment:
+ return False
+ if body2 is environment:
+ return False
+
+ return bool(dAreConnected(<dBodyID> body1.bid, <dBodyID> body2.bid))
+
+
+def CloseODE():
+ """CloseODE()
+
+ Deallocate some extra memory used by ODE that can not be deallocated
+ using the normal destroy functions.
+ """
+ dCloseODE()
+
+
+def InitODE():
+ '''InitODE()
+
+ Initialize some ODE internals. This will be called for you when you
+ "import ode", but you should call this again if you CloseODE().'''
+ dInitODE()
+
+
+#environment = Body(None)
+environment = None
+InitODE()
diff --git a/libs/ode-0.16.1/bindings/python/setup.py b/libs/ode-0.16.1/bindings/python/setup.py new file mode 100644 index 0000000..f0c5763 --- /dev/null +++ b/libs/ode-0.16.1/bindings/python/setup.py @@ -0,0 +1,48 @@ +#! /usr/bin/env python +from distutils.core import setup +from distutils.extension import Extension +from subprocess import Popen, PIPE, CalledProcessError + + +try: + from Cython.Distutils import build_ext +except ImportError: + raise SystemExit("Requires Cython (http://cython.org/)") + +try: + ode_cflags = Popen( + ["pkg-config", "--cflags", "ode"], + stdout=PIPE).stdout.read().decode('ascii').split() + ode_libs = Popen( + ["pkg-config", "--libs", "ode"], + stdout=PIPE).stdout.read().decode('ascii').split() +except (OSError, CalledProcessError): + raise SystemExit("Failed to find ODE with 'pkg-config'. Please make sure " + "that it is installed and available on your system path.") + +ode_ext = Extension("ode", ["ode.pyx"], + extra_compile_args=ode_cflags, + extra_link_args=ode_libs) + +if __name__ == "__main__": + setup( + name="Open Dynamics Engine", + version="0.12", + author="Gideon Klompje", +# author_email="", +# maintainer="", +# maintainer_email="", + url="http://www.ode.org", + description="Bindings for the Open Dynamics Engine", + long_description=( + "A free, industrial quality library for simulating articulated " + "rigid body dynamics - for example ground vehicles, legged " + "creatures, and moving objects in VR environments. It's fast, " + "flexible & robust. Built-in collision detection."), +# download_url="https://opende.svn.sourceforge.net/svnroot/opende", +# classifiers=[], +# platforms=[], + license="BSD License, GNU Lesser General Public License (LGPL)", + cmdclass={"build_ext": build_ext}, + ext_modules=[ode_ext] + ) |