def setBall(self, ball, value):
"""Set a new value for a particular ball.
This method sends a JOYSTICK_BALL event.
\param ball (\c int) Ball index
\param value (\c float) Ball value
"""
self.ball[ball] = value
e = JoystickBallEvent(self.id, ball, value)
eventManager().event(JOYSTICK_BALL, e)
def setBall(self, ball, value):
"""Set a new value for a particular ball.
This method sends a JOYSTICK_BALL event.
\param ball (\c int) Ball index
\param value (\c float) Ball value
"""
self.ball[ball] = value
e = JoystickBallEvent(self.id, ball, value)
eventManager().event(JOYSTICK_BALL, e)
def setHat(self, hat, x, y):
"""Set a new value for a particular hat.
This method sends a JOYSTICK_HAT event.
\param hat (\c int) Hat index
\param x (\c int) X value
\param y (\c int) Y value
"""
self.hat[hat]=(x,y)
e = JoystickHatEvent(self.id, hat, x, y)
eventManager().event(JOYSTICK_HAT, e)
def setHat(self, hat, x, y):
"""Set a new value for a particular hat.
This method sends a JOYSTICK_HAT event.
\param hat (\c int) Hat index
\param x (\c int) X value
\param y (\c int) Y value
"""
self.hat[hat] = (x, y)
e = JoystickHatEvent(self.id, hat, x, y)
eventManager().event(JOYSTICK_HAT, e)
def setButton(self, button, value):
"""Set the state of a particular button.
This method sends either a JOYSTICK_BUTTON_DOWN or
JOYSTICK_BUTTON_UP event.
\param button (\c int) Button index
\param value (\c bool) State of the button (True = pressed)
"""
self.button[button] = value
e = JoystickButtonEvent(self.id, button)
if value:
eventManager().event(JOYSTICK_BUTTON_DOWN, e)
else:
eventManager().event(JOYSTICK_BUTTON_UP, e)
def setButton(self, button, value):
"""Set the state of a particular button.
This method sends either a JOYSTICK_BUTTON_DOWN or
JOYSTICK_BUTTON_UP event.
\param button (\c int) Button index
\param value (\c bool) State of the button (True = pressed)
"""
self.button[button] = value
e = JoystickButtonEvent(self.id, button)
if value:
eventManager().event(JOYSTICK_BUTTON_DOWN, e)
else:
eventManager().event(JOYSTICK_BUTTON_UP, e)
def __init__(self, name="SlideShow", slides=[], auto_insert=True):
component.Component.__init__(self, name, auto_insert)
if isinstance(slides, types.StringTypes):
slides = Slide(slides)
try:
len(slides)
except:
slides = [slides]
self.images = []
for s in slides:
for f in s.files:
self.images.append((f, s.transition))
# Currently displayed image index
self.imageidx = 0
self.setup()
em = eventManager()
em.connect(STEP_FRAME, self)
em.connect(LEFT_DOWN, self)
em.connect(KEY_PRESS, self)
self.transition = self.images[0][1]
# Global time when the next transition starts
# self.transition_start = 3.0
self.transition_start = 999999.0
# Slide show state
self.state = 0
def importFile(self, filename):
"""Import a Python source file."""
file_globals = {}
# Use all globals from the cgkit package
# Commented out the following line as is imported from cgkit.all now
# file_globals = copy.copy(cgkit.__dict__)
# Add some modules...
exec "from cgkit.all import *" in file_globals
exec "from cgkit.sl import *" in file_globals
exec "from math import *" in file_globals
# ...and some special global names...
scene = globalscene.getScene()
file_globals["scene"] = scene
file_globals["timer"] = scene.timer()
file_globals["worldroot"] = scene.worldRoot()
file_globals["eventmanager"] = eventmanager.eventManager()
paths = sys.path
# Add the directory of the input file to the module search paths
# so that local imports do work
sys.path = [os.path.abspath(os.path.dirname(filename))] + sys.path
# Import the file
execfile(filename, file_globals)
# Restore the old search paths
sys.path = paths
def __init__(self,
cam,
name = "CameraControl",
mode = 0,
auto_insert = True):
"""Constructor.
\param cam (\c ...Cam?...) Camera to control
\param name (\c str) Name of the component
\param mode (\c int) 0=Emulate MAX behavior, 1=Emulate Maya behavior
\param auto_insert (\c bool) Insert into scene or not
"""
component.Component.__init__(self, name=name, auto_insert=auto_insert)
# mode: 0=Emulate MAX / 1=Emulate Maya / 2=Emulate Softimage (Navigation tool)
self.mode = mode
self.cam = cam
self.left_down = False
self.middle_down = False
self.right_down = False
self.alt_down = False
self.ctrl_down = False
em = eventmanager.eventManager()
em.connect(KEY_PRESS, self)
em.connect(KEY_RELEASE, self)
em.connect(LEFT_DOWN, self)
em.connect(LEFT_UP, self)
em.connect(MIDDLE_DOWN, self)
em.connect(MIDDLE_UP, self)
em.connect(RIGHT_DOWN, self)
em.connect(RIGHT_UP, self)
em.connect(MOUSE_MOVE, self)
em.connect(MOUSE_WHEEL, self)
em.connect(SPACE_MOTION, self)
def importFile(self, filename):
"""Import a Python source file."""
file_globals = {}
# Use all globals from the cgkit package
# Commented out the following line as is imported from cgkit.all now
# file_globals = copy.copy(cgkit.__dict__)
# Add some modules...
exec "from cgkit.all import *" in file_globals
exec "from cgkit.sl import *" in file_globals
exec "from math import *" in file_globals
# ...and some special global names...
scene = globalscene.getScene()
file_globals["scene"] = scene
file_globals["timer"] = scene.timer()
file_globals["worldroot"] = scene.worldRoot()
file_globals["eventmanager"] = eventmanager.eventManager()
paths = sys.path
# Add the directory of the input file to the module search paths
# so that local imports do work
sys.path = [os.path.abspath(os.path.dirname(filename))] + sys.path
# Import the file
execfile(filename, file_globals)
# Restore the old search paths
sys.path = paths
def __init__(self,
name = "PIDController",
setpoint = 0.0,
Kp = 0.0,
Ki = 0.0,
Kd = 0.0,
maxout = 999999,
minout = -999999,
auto_insert = True):
"""Constructor.
"""
component.Component.__init__(self, name, auto_insert)
self.input_slot = DoubleSlot()
self.setpoint_slot = DoubleSlot(setpoint)
self.maxout_slot = DoubleSlot(maxout)
self.minout_slot = DoubleSlot(minout)
self.Kp_slot = DoubleSlot(Kp)
self.Ki_slot = DoubleSlot(Ki)
self.Kd_slot = DoubleSlot(Kd)
self.output_slot = ProceduralDoubleSlot(self.computeOutput)
self.addSlot("input", self.input_slot)
self.addSlot("setpoint", self.setpoint_slot)
self.addSlot("output", self.output_slot)
self.addSlot("maxout", self.maxout_slot)
self.addSlot("minout", self.minout_slot)
self.addSlot("Kp", self.Kp_slot)
self.addSlot("Ki", self.Ki_slot)
self.addSlot("Kd", self.Kd_slot)
self.input_slot.addDependent(self.output_slot)
self.setpoint_slot.addDependent(self.output_slot)
self.maxout_slot.addDependent(self.output_slot)
self.minout_slot.addDependent(self.output_slot)
self.Kp_slot.addDependent(self.output_slot)
self.Ki_slot.addDependent(self.output_slot)
self.Kd_slot.addDependent(self.output_slot)
self._integral = 0.0
self._prev_err = 0.0
eventmanager.eventManager().connect(events.STEP_FRAME, self)
eventmanager.eventManager().connect(events.RESET, self)
def __init__(self,
name="PIDController",
setpoint=0.0,
Kp=0.0,
Ki=0.0,
Kd=0.0,
maxout=999999,
minout=-999999,
auto_insert=True):
"""Constructor.
"""
component.Component.__init__(self, name, auto_insert)
self.input_slot = DoubleSlot()
self.setpoint_slot = DoubleSlot(setpoint)
self.maxout_slot = DoubleSlot(maxout)
self.minout_slot = DoubleSlot(minout)
self.Kp_slot = DoubleSlot(Kp)
self.Ki_slot = DoubleSlot(Ki)
self.Kd_slot = DoubleSlot(Kd)
self.output_slot = ProceduralDoubleSlot(self.computeOutput)
self.addSlot("input", self.input_slot)
self.addSlot("setpoint", self.setpoint_slot)
self.addSlot("output", self.output_slot)
self.addSlot("maxout", self.maxout_slot)
self.addSlot("minout", self.minout_slot)
self.addSlot("Kp", self.Kp_slot)
self.addSlot("Ki", self.Ki_slot)
self.addSlot("Kd", self.Kd_slot)
self.input_slot.addDependent(self.output_slot)
self.setpoint_slot.addDependent(self.output_slot)
self.maxout_slot.addDependent(self.output_slot)
self.minout_slot.addDependent(self.output_slot)
self.Kp_slot.addDependent(self.output_slot)
self.Ki_slot.addDependent(self.output_slot)
self.Kd_slot.addDependent(self.output_slot)
self._integral = 0.0
self._prev_err = 0.0
eventmanager.eventManager().connect(events.STEP_FRAME, self)
eventmanager.eventManager().connect(events.RESET, self)
def __init__(self, name="AutoCam"):
Component.__init__(self, name=name)
# Input
self.input_slot = slots.Vec3Slot()
self.addSlot("input", self.input_slot)
# Output
self.output_slot = slots.Vec3Slot()
self.addSlot("output", self.output_slot)
self.accel_factor = 0.5
self.out_offset = vec3(0, 0, 0)
self.out = vec3(0, 0, 0)
self.out_velocity = vec3(0, 0, 0)
eventManager().connect(events.STEP_FRAME, self)
def __init__(self, name="AutoCam"):
Component.__init__(self, name=name)
# Input
self.input_slot = slots.Vec3Slot()
self.addSlot("input", self.input_slot)
# Output
self.output_slot = slots.Vec3Slot()
self.addSlot("output", self.output_slot)
self.accel_factor = 0.5
self.out_offset = vec3(0,0,0)
self.out = vec3(0,0,0)
self.out_velocity = vec3(0,0,0)
eventManager().connect(events.STEP_FRAME, self)
def __init__(self, name="Timer", auto_insert=True):
Component.__init__(self, name=name, auto_insert=auto_insert)
# The time() value when the clock was started
self._clock_start = 0.0
# This offset is added to the returned clock value. It stores the
# clock value at the time the clock was stopped
self._clock_offset = 0.0
# This flag indicates if the clock is running or not
self._clock_running = False
self._duration = 1.0
self._framecount = 25
self._fps = 25
self._timestep = 0.04
# Virtual time...
self.time_slot = slots.DoubleSlot()
self.addSlot("time", self.time_slot)
eventManager().connect(events.RESET, self)
def __init__(self, name="Timer", auto_insert=True):
Component.__init__(self, name=name, auto_insert=auto_insert)
# The time() value when the clock was started
self._clock_start = 0.0
# This offset is added to the returned clock value. It stores the
# clock value at the time the clock was stopped
self._clock_offset = 0.0
# This flag indicates if the clock is running or not
self._clock_running = False
self._duration = 1.0
self._framecount = 25
self._fps = 25
self._timestep = 0.04
# Virtual time...
self.time_slot = slots.DoubleSlot()
self.addSlot("time", self.time_slot)
eventManager().connect(events.RESET, self)
def setAxis(self, axis, value):
"""Set a new value for a particular axis.
The value is the raw (uncalibrated) value from the joystick.
This method sends a JOYSTICK_AXIS event which contains the
\em calibrated axis value.
\param axis (\c int) Axis index
\param value (\c float) Uncalibrated axis value
\todo Sollte diese Methode setRawAxis() heissen?
"""
self.axis[axis] = value
# Adjust min/max values
if value < self.axis_min[axis]:
self.axis_min[axis] = value
if value > self.axis_max[axis]:
self.axis_max[axis] = value
e = JoystickAxisEvent(self.id, axis, self._calibratedAxis(axis, value))
eventManager().event(JOYSTICK_AXIS, e)
def setAxis(self, axis, value):
"""Set a new value for a particular axis.
The value is the raw (uncalibrated) value from the joystick.
This method sends a JOYSTICK_AXIS event which contains the
\em calibrated axis value.
\param axis (\c int) Axis index
\param value (\c float) Uncalibrated axis value
\todo Sollte diese Methode setRawAxis() heissen?
"""
self.axis[axis] = value
# Adjust min/max values
if value<self.axis_min[axis]:
self.axis_min[axis] = value
if value>self.axis_max[axis]:
self.axis_max[axis] = value
e = JoystickAxisEvent(self.id, axis, self._calibratedAxis(axis, value))
eventManager().event(JOYSTICK_AXIS, e)
def onStepFrame(self):
timer = getScene().timer()
### State 0: Waiting for the transition
if self.state==0:
if timer.time>=self.transition_start:
self.state = 1
### State 1: Begin of transition
if self.state==1:
self.transition.preTransition(self)
eventManager().event("SlidePreTransition", self.images[self.imageidx][0])
self.state = 2
### State 2: Transition
if self.state==2:
if self.transition.duration>0:
t = (timer.time-self.transition_start)/self.transition.duration
else:
t = 1.0
if t>1.0:
t = 1.0
self.transition.doTransition(self, t)
eventManager().event("SlideDoTransition", t)
if t==1.0:
self.state = 3
### State 3: Transition is over
elif self.state==3:
eventManager().event("SlidePostTransition")
self.transition.postTransition(self)
self.switchSlide()
self.frontplate.transform = mat4(1)
self.backplate.transform = mat4(1)
self.backplate.pos = vec3(0,0,-1)
# self.transition_start += 5.0
self.transition_start = 999999.0
self.state = 0
def reset():
"""Reset an animation/simulation.
Reset effectively sets the time back to 0.
"""
eventmanager.eventManager().event(events.RESET)
def __init__(self,
name = "GnuPlotter",
title = None,
xlabel = None,
ylabel = None,
xrange = None,
yrange = None,
inputs = 1,
plottitles = [],
starttime = 0.0,
endtime = 99999.0,
enabled = True,
auto_insert = True):
"""Constructor.
"""
global gnuplot_installed
component.Component.__init__(self, name, auto_insert)
self.enabled = enabled
self.inputs = inputs
self.plot_data = []
self.starttime = starttime
self.endtime = endtime
for i in range(inputs):
s = DoubleSlot()
exec "self.input%d_slot = s"%(i+1)
if i<len(plottitles):
t = plottitles[i]
else:
t = None
pd = _PlotDesc(slot=s, title=t)
self.plot_data.append(pd)
if not enabled:
return
if not gnuplot_installed:
print >>sys.stderr, "Warning: PyGnuplot is not installed"
return
self.gp = Gnuplot.Gnuplot()
self.gp('set data style lines')
self.gp("set grid")
self.gp("set xzeroaxis")
if title!=None:
self.gp.title(title)
if xlabel!=None:
self.gp.xlabel(xlabel)
if ylabel!=None:
self.gp.ylabel(ylabel)
if yrange!=None:
self.gp.set_range("yrange",yrange)
# self.gp("set yrange [%f:%f]"%tuple(yrange))
if xrange!=None:
self.gp.set_range("xrange",xrange)
self._delay = 0
eventmanager.eventManager().connect(events.STEP_FRAME, self)
def __init__(self,
name = "FlockOfBirds",
com_port = 0,
baud_rate = 115200,
timeout = 2.0,
num_birds = 1,
bird_mode = "p",
hemisphere = "forward",
auto_insert = True):
"""Constructor.
The bird mode is one of "p" (position), "a" (angles), "m" (matrix),
"q" (quaternion) or a combination like "pa", "pm" and "pq".
The argument \a bird_mode can either be a mode string that will
be used for all birds, or it can be a list of mode strings for
every bird.
\param name (\c str) Component name
\param com_port (\c int) COM port to use for communicating with the flock (0,1,...)
\param baud_rate (\c int) Baud rate
\param timeout (\c float) Time out value in seconds for RS232 operations
\param num_birds (\c int) Number of birds to use (including the ERC)
\param bird_mode (\c str or \c list) Tracker mode (selects what kind of data the birds will send)
\param hemisphere (\c str) Hemisphere setting for the transmitter ("forward", "aft", "upper", "lower", "left", "right")
\param auto_insert (\c bool) True if the component should be inserted into the scene automatically
"""
component.Component.__init__(self, name, auto_insert)
self.com_port = com_port
self.baud_rate = baud_rate
self.timeout = timeout
self.num_birds = num_birds
self.hemisphere = hemisphere
if isinstance(bird_mode, types.StringTypes):
self.bird_mode = self.num_birds*[bird_mode]
else:
self.bird_mode = bird_mode
self.bird_mode = map(lambda x: x.upper(), self.bird_mode)
if len(self.bird_mode)!=self.num_birds:
raise ValueError("%d bird modes expected (got %d)"%(self.num_birds, len(self.bird_mode)))
# Create slots
self._slots = []
for i in range(self.num_birds):
p = Vec3Slot()
a = Vec3Slot()
m = Mat3Slot(mat3(1))
q = QuatSlot(quat(1))
self._slots.append((p,a,m,q))
setattr(self, "pos%d_slot"%(i+1), p)
setattr(self, "angle%d_slot"%(i+1), a)
setattr(self, "matrix%d_slot"%(i+1), m)
setattr(self, "quat%d_slot"%(i+1), q)
self.addSlot("pos%d"%(i+1), p)
self.addSlot("angle%d"%(i+1), a)
self.addSlot("matrix%d"%(i+1), m)
self.addSlot("quat%d"%(i+1), q)
# Initialize the FOB...
self._fob = fob.FOB()
self._fob.open(self.com_port, self.baud_rate, self.timeout)
self._fob.fbbAutoConfig(numbirds=self.num_birds)
self._fob.fbbReset()
hs = { "forward":fob.FORWARD,
"aft":fob.AFT,
"upper":fob.UPPER,
"lower":fob.LOWER,
"left":fob.LEFT,
"right":fob.RIGHT }
for i in range(1, self.num_birds):
self._fob.hemisphere(hs[self.hemisphere.lower()], addr=i+1)
self.setTrackerMode(self.bird_mode[i], i+1)
self._fob.run()
eventmanager.eventManager().connect(events.STEP_FRAME, self)
def __init__(self,
name="FlockOfBirds",
com_port=0,
baud_rate=115200,
timeout=2.0,
num_birds=1,
bird_mode="p",
hemisphere="forward",
auto_insert=True):
"""Constructor.
The bird mode is one of "p" (position), "a" (angles), "m" (matrix),
"q" (quaternion) or a combination like "pa", "pm" and "pq".
The argument \a bird_mode can either be a mode string that will
be used for all birds, or it can be a list of mode strings for
every bird.
\param name (\c str) Component name
\param com_port (\c int) COM port to use for communicating with the flock (0,1,...)
\param baud_rate (\c int) Baud rate
\param timeout (\c float) Time out value in seconds for RS232 operations
\param num_birds (\c int) Number of birds to use (including the ERC)
\param bird_mode (\c str or \c list) Tracker mode (selects what kind of data the birds will send)
\param hemisphere (\c str) Hemisphere setting for the transmitter ("forward", "aft", "upper", "lower", "left", "right")
\param auto_insert (\c bool) True if the component should be inserted into the scene automatically
"""
component.Component.__init__(self, name, auto_insert)
self.com_port = com_port
self.baud_rate = baud_rate
self.timeout = timeout
self.num_birds = num_birds
self.hemisphere = hemisphere
if isinstance(bird_mode, types.StringTypes):
self.bird_mode = self.num_birds * [bird_mode]
else:
self.bird_mode = bird_mode
self.bird_mode = map(lambda x: x.upper(), self.bird_mode)
if len(self.bird_mode) != self.num_birds:
raise ValueError("%d bird modes expected (got %d)" %
(self.num_birds, len(self.bird_mode)))
# Create slots
self._slots = []
for i in range(self.num_birds):
p = Vec3Slot()
a = Vec3Slot()
m = Mat3Slot(mat3(1))
q = QuatSlot(quat(1))
self._slots.append((p, a, m, q))
setattr(self, "pos%d_slot" % (i + 1), p)
setattr(self, "angle%d_slot" % (i + 1), a)
setattr(self, "matrix%d_slot" % (i + 1), m)
setattr(self, "quat%d_slot" % (i + 1), q)
self.addSlot("pos%d" % (i + 1), p)
self.addSlot("angle%d" % (i + 1), a)
self.addSlot("matrix%d" % (i + 1), m)
self.addSlot("quat%d" % (i + 1), q)
# Initialize the FOB...
self._fob = fob.FOB()
self._fob.open(self.com_port, self.baud_rate, self.timeout)
self._fob.fbbAutoConfig(numbirds=self.num_birds)
self._fob.fbbReset()
hs = {
"forward": fob.FORWARD,
"aft": fob.AFT,
"upper": fob.UPPER,
"lower": fob.LOWER,
"left": fob.LEFT,
"right": fob.RIGHT
}
for i in range(1, self.num_birds):
self._fob.hemisphere(hs[self.hemisphere.lower()], addr=i + 1)
self.setTrackerMode(self.bird_mode[i], i + 1)
self._fob.run()
eventmanager.eventManager().connect(events.STEP_FRAME, self)
def step(self):
t = self.time_slot.getValue() + self._timestep
self.time_slot.setValue(t)
eventManager().event(events.STEP_FRAME)
def __init__(
self,
name="GnuPlotter",
title=None,
xlabel=None,
ylabel=None,
xrange=None,
yrange=None,
inputs=1,
plottitles=[],
starttime=0.0,
endtime=99999.0,
enabled=True,
auto_insert=True,
):
"""Constructor.
"""
global gnuplot_installed
component.Component.__init__(self, name, auto_insert)
self.enabled = enabled
self.inputs = inputs
self.plot_data = []
self.starttime = starttime
self.endtime = endtime
for i in range(inputs):
s = DoubleSlot()
exec "self.input%d_slot = s" % (i + 1)
if i < len(plottitles):
t = plottitles[i]
else:
t = None
pd = _PlotDesc(slot=s, title=t)
self.plot_data.append(pd)
if not enabled:
return
if not gnuplot_installed:
print >>sys.stderr, "Warning: PyGnuplot is not installed"
return
self.gp = Gnuplot.Gnuplot()
self.gp("set data style lines")
self.gp("set grid")
self.gp("set xzeroaxis")
if title != None:
self.gp.title(title)
if xlabel != None:
self.gp.xlabel(xlabel)
if ylabel != None:
self.gp.ylabel(ylabel)
if yrange != None:
self.gp.set_range("yrange", yrange)
# self.gp("set yrange [%f:%f]"%tuple(yrange))
if xrange != None:
self.gp.set_range("xrange", xrange)
self._delay = 0
eventmanager.eventManager().connect(events.STEP_FRAME, self)
def __init__(self,
name="ODEDynamics",
gravity = 9.81,
substeps = 1,
cfm = None,
erp = None,
defaultcontactproperties = None,
enabled = True,
show_contacts = False,
contactmarkersize = 0.1,
contactnormalsize = 1.0,
collision_events = False,
auto_add = False,
auto_insert=True):
"""Constructor.
\param name (\c str) Component name
\param auto_add (\c bool) Automatically add the world objects to the simulation
\param auto_insert (\c bool) Automatically add the component to the scene
"""
Component.__init__(self, name=name, auto_insert=auto_insert)
scene = getScene()
self.substeps = substeps
self.collision_events = collision_events
self.world = ode.World()
g = -gravity*scene.up
self.world.setGravity(g)
if cfm!=None:
self.world.setCFM(cfm)
if erp!=None:
self.world.setERP(erp)
# self.world.setAutoDisableFlag(True)
self.enabled = enabled
self.eventmanager = eventManager()
self.eventmanager.connect(STEP_FRAME, self)
self.eventmanager.connect(RESET, self.reset)
# Space object
self.space = ode.Space()
# Joint group for the contact joints
self.contactgroup = ode.JointGroup()
# A dictionary with WorldObjects as keys and ODEBodies as values
self.body_dict = {}
# A list of all bodies
self.bodies = []
# A list of all joints
self.joints = []
# A dictionary with contact properties
# Key is a 2-tuple (material1, material2). Value is a
# ODEContactProperties object.
# The value of (mat1, mat2) should always be the same than
# the value of (mat2, mat1).
self.contactprops = {}
# Default contact properties
if defaultcontactproperties==None:
defaultcontactproperties = ODEContactProperties()
self.defaultcontactprops = defaultcontactproperties
self.show_contacts = show_contacts
self.contactmarkersize = contactmarkersize
self.contactnormalsize = contactnormalsize
# A list of weakrefs to body manipulators
self.body_manips = []
# Debug statistics (the number of contacts per simulation step)
self.numcontacts = 0
# Automatically add world objects
if auto_add:
# Add all rigid bodies first...
for obj in scene.worldRoot().iterChilds():
try:
obj = protocols.adapt(obj, IRigidBody)
self.add(obj)
except NotImplementedError:
pass
# Then add all joints...
for obj in scene.worldRoot().iterChilds():
if isinstance(obj, ODEJointBase):
self.add(obj)
def __init__(self,
name="ODEDynamics",
gravity=9.81,
substeps=1,
cfm=None,
erp=None,
defaultcontactproperties=None,
enabled=True,
show_contacts=False,
contactmarkersize=0.1,
contactnormalsize=1.0,
collision_events=False,
auto_add=False,
auto_insert=True):
"""Constructor.
\param name (\c str) Component name
\param auto_add (\c bool) Automatically add the world objects to the simulation
\param auto_insert (\c bool) Automatically add the component to the scene
"""
Component.__init__(self, name=name, auto_insert=auto_insert)
scene = getScene()
self.substeps = substeps
self.collision_events = collision_events
self.world = ode.World()
g = -gravity * scene.up
self.world.setGravity(g)
if cfm != None:
self.world.setCFM(cfm)
if erp != None:
self.world.setERP(erp)
# self.world.setAutoDisableFlag(True)
self.enabled = enabled
self.eventmanager = eventManager()
self.eventmanager.connect(STEP_FRAME, self)
self.eventmanager.connect(RESET, self.reset)
# Space object
self.space = ode.Space()
# Joint group for the contact joints
self.contactgroup = ode.JointGroup()
# A dictionary with WorldObjects as keys and ODEBodies as values
self.body_dict = {}
# A list of all bodies
self.bodies = []
# A list of all joints
self.joints = []
# A dictionary with contact properties
# Key is a 2-tuple (material1, material2). Value is a
# ODEContactProperties object.
# The value of (mat1, mat2) should always be the same than
# the value of (mat2, mat1).
self.contactprops = {}
# Default contact properties
if defaultcontactproperties == None:
defaultcontactproperties = ODEContactProperties()
self.defaultcontactprops = defaultcontactproperties
self.show_contacts = show_contacts
self.contactmarkersize = contactmarkersize
self.contactnormalsize = contactnormalsize
# A list of weakrefs to body manipulators
self.body_manips = []
# Debug statistics (the number of contacts per simulation step)
self.numcontacts = 0
# Automatically add world objects
if auto_add:
# Add all rigid bodies first...
for obj in scene.worldRoot().iterChilds():
try:
obj = protocols.adapt(obj, IRigidBody)
self.add(obj)
except NotImplementedError:
pass
# Then add all joints...
for obj in scene.worldRoot().iterChilds():
if isinstance(obj, ODEJointBase):
self.add(obj)
def reset():
"""Reset an animation/simulation.
Reset effectively sets the time back to 0.
"""
eventmanager.eventManager().event(events.RESET)
def step(self):
t = self.time_slot.getValue() + self._timestep
self.time_slot.setValue(t)
eventManager().event(events.STEP_FRAME)
