| Next revision | Previous revision |
| public:t-vien-10-3:lab_4_materials:ode [2010/10/06 22:01] – created hannes | public:t-vien-10-3:lab_4_materials:ode [2024/04/29 13:33] (current) – external edit 127.0.0.1 |
|---|
| ====== Factory Scene with ODE ====== | ====== Factory Scene with ODE ====== |
| - You can incorporate this engine into your Panda environments using the [[http://pyode.sourceforge.net/|open-source PyODE module]]. Start by downloading and installing this module (remember to get the version for Python 2.4 to match the version that Panda uses). Now all you have to do to use ODE in your Panda program is to add **''import ode''**. Follow these steps to redo the factory scene with ODE, simply by modifying the code you have so far. (This code is based on the excellent PyODE tutorials as well as on several Panda 3D forum posts) \\ | ODE is already included in the Panda3D 1.7.0 distribution. The ODE classes are all under **pandac.PandaModules**, so since you've already imported everything from there into your program (using the '*'), you don't have to do anything to start using them. \\ |
| - The simulation actually takes place in two separate invisible simulation environments, one for the physics (called ''world'') and another for collision handling (called ''space''). So the first thing you do (you can do all of this in the constructor of your **World** class) is to instantiate and set up these two environments: <code python> | - The simulation actually takes place in two separate invisible simulation environments, one for the physics (called ''world'') and another for collision handling (called ''space''). So the first thing you do (you can do all of this in the constructor of your **World** class) is to instantiate and set up these two environments: <code python> |
| self.world = ode.World() # Create a physics/dynamics environment | # Set up the physical world |
| self.world.setGravity((0,0,-9.81)) # Add earth gravity in the negative z-dimension | self.world = OdeWorld() |
| self.space = ode.Space() # Create a collision environment | self.world.setGravity((0,0,-9.81)) |
| | # Surface properties |
| | self.world.initSurfaceTable(1) # We define 1 surface material |
| | self.world.setSurfaceEntry(0, 0, 150, 0.0, 9.1, 0.9, 0.00001, 0.0, 0.002) # Default surface material |
| | # Simulation space with collision |
| | self.space = OdeSimpleSpace() |
| | self.space.setAutoCollideWorld(self.world) |
| | self.contactgroup = OdeJointGroup() |
| | self.space.setAutoCollideJointGroup(self.contactgroup) |
| | self.space.setCollisionEvent("collision") |
| </code> For each object you want to be part of the physics simulation, you have to create a physical body. Here is how the physical body of the box is created (note that you still need your original Panda model of the box, that's the //visible// version of the box): <code python> | </code> For each object you want to be part of the physics simulation, you have to create a physical body. Here is how the physical body of the box is created (note that you still need your original Panda model of the box, that's the //visible// version of the box): <code python> |
| self.boxbody = ode.Body(self.world) # Instantiate a physical body in the physical environment | # Physical body for the box |
| self.boxbody.size = (0.3, 0.3, 0.3) # Store the size of the body | self.boxbody = OdeBody(self.world) |
| self.boxbody.setPosition((1,0,2)) # Place the body in the same location as in the Panda environment | self.boxbody.setPosition((1,0,2)) |
| self.boxbody.addForce((0,0,1000)) # This is just for fun: give the box an upward kick at the beginning | self.boxbody.addForce((0,0,1000)) |
| self.boxmass = ode.Mass() # Define a physical mass for the box | self.boxmass = OdeMass() |
| self.boxmass.setBox(500, *self.boxbody.size) # The mass is defined as density and size | self.boxmass.setBox(500, 0.3, 0.3, 0.3) |
| self.boxbody.setMass(self.boxmass) # Add the mass to the physical body of the box | self.boxbody.setMass(self.boxmass) |
| </code> Now that you have a physical representation of the box, you still need to make an ODE collision solid for it and put into the collision environment. This is how: <code python> | </code> Now that you have a physical representation of the box, you still need to make an ODE collision solid for it and put into the collision environment. This is how: <code python> |
| self.boxsolid = ode.GeomBox(self.space, self.boxbody.size) | # Collision body for the box |
| self.boxsolid.setBody(self.boxbody) | self.boxsolid = OdeBoxGeom(self.space, 0.3, 0.3, 0.3) |
| </code> To see the effect of gravity (and the kicking force) on the box, you will now have to start a task that copies the position of the physical box to the position of the visual box at every frame, and advances the physics simulation world by one step: <code python> | self.boxsolid.setCollideBits(BitMask32(0x00000001)) # Filters what objects this Box can collide into (required category) |
| taskMgr.add(self.simulate, 'ODE Simulation') | self.boxsolid.setCategoryBits(BitMask32(0x00000001)) # The Box itself is of that same category |
| def simulate(self, task): | self.boxsolid.setBody(self.boxbody) |
| x,y,z = self.boxbody.getPosition() # Get position of the simulated physical box | </code> To see the effect of gravity on the box, you will now have to start a task that copies the position of the physical box to the position of the visual box at every frame, and advances the physics simulation world by one step: <code python> |
| self.box.setPos(Vec3(x,y,z)) # Set the position of the visual box | taskMgr.add(self.simulate, 'ODE Simulation') |
| self.world.step(0.04) # Increment time in the physical simulation | |
| return Task.cont # Keep this task running forever | def simulate(self, task): |
| | self.space.autoCollide() # Resolve collisions |
| | # Set the position and rotation of the graphical box from the physical box |
| | self.box.setPosQuat (render, self.boxbody.getPosition(), Quat(self.boxbody.getQuaternion())) |
| | self.world.quickStep(globalClock.getDt()) # Advance the simulation |
| | self.contactgroup.empty() # Clear collected collisions |
| | return Task.cont |
| </code> Test this and make sure gravity is working as expected. Make sure to comment out the LerpPosInterval for the box since you no longer need it! You should also change the left mouse button handler so that it sets the position of both the visual box and the physical box back to the original position (to maintain similar functionality as before). You will also want to set the linear velocity of the box to 0 like this **''self.boxbody.setLinearVel( (0,0,0) )''**, otherwise the box will keep going faster and faster\\ | </code> Test this and make sure gravity is working as expected. Make sure to comment out the LerpPosInterval for the box since you no longer need it! You should also change the left mouse button handler so that it sets the position of both the visual box and the physical box back to the original position (to maintain similar functionality as before). You will also want to set the linear velocity of the box to 0 like this **''self.boxbody.setLinearVel( (0,0,0) )''**, otherwise the box will keep going faster and faster\\ |
| - To introduce collision with the door, you will need to create both a physical body for the door and a ODE collision solid for the door, just like you did for the box. Try using **size** of **(2,2,0.1)** and **density** of **1000**. Don't forget to update the door's visual position based on the physical position in the simulation task! In fact, this time, let's update both the position and the rotation of both objects. The problem is that ODE uses a matrix representation for rotation, so it needs to be converted into a format that Panda understands, which happens to be the quaternion format. Here is a function that will set the position and rotation of a Panda model, given position and rotation in ODE format (just add this as a utility function near the top of your program): <code python> | - To introduce collision with the door, you will need to create both a physical body for the door and a ODE collision solid for the door, just like you did for the box. Try using **size** of **(2,4,0.1)** and **density** of **1000**. Don't forget to update the door's visual position based on the physical position in the simulation task! Your **''simulate''** task should now look like this: <code python> |
| def set_model_odeposrot(model, body): | def simulate(self, task): |
| pos = body.getPosition() | self.space.autoCollide() |
| quat = body.getQuaternion() | self.box.setPosQuat (render, self.boxbody.getPosition(), Quat(self.boxbody.getQuaternion())) |
| model.setPosQuat (VBase3(pos[0],pos[1],pos[2]), Quat(quat[0],quat[1],quat[2],quat[3])) | self.door.setPosQuat(render, self.doorbody.getPosition(), Quat(self.doorbody.getQuaternion())) |
| </code> Your **''simulate''** task should now look like this: <code python> | self.world.quickStep(globalClock.getDt()) |
| def simulate(self, task): | self.contactgroup.empty() |
| set_model_odeposrot(self.box, self.boxbody.getPosition(), self.boxbody.getRotation()) | return Task.cont |
| set_model_odeposrot(self.door, self.doorbody.getPosition(), self.doorbody.getRotation()) | |
| self.world.step(0.04) | |
| return Task.cont | |
| </code> You may notice that the door naturally falls down along with the box since there is nothing holding it up! We'll fix that next. \\ | </code> You may notice that the door naturally falls down along with the box since there is nothing holding it up! We'll fix that next. \\ |
| - You need to attach the door to the environment so that it doesn't fall. In fact, the door is attached to the environment with a so-called **slider joint** because it can slide from side-to-side. ODE provides a number of [[http://opende.sourceforge.net/mediawiki-1.6.10/index.php/Manual_%28Joint_Types_and_Functions%29|joints]] for attaching objects to each other or to the environment. You create and attach the slider joint like this: <code python> | - You need to attach the door to the environment so that it doesn't fall. In fact, the door is attached to the environment with a so-called **slider joint** because it can slide from side-to-side. ODE provides a number of [[http://opende.sourceforge.net/mediawiki-1.6.10/index.php/Manual_%28Joint_Types_and_Functions%29|joints]] for attaching objects to each other or to the environment. You create and attach the slider joint like this: <code python> |
| self.doorslider = ode.SliderJoint(self.world) # Instantiating a new slider joint | # Sliding motor for the door |
| self.doorslider.attach(self.doorbody, ode.environment) # Using the joint to attach door body to environment | self.doorslider = OdeSliderJoint(self.world) # Instantiating a new slider joint |
| self.doorslider.setAxis((1,0,0)) # Slides along the x-axis | self.doorslider.attach(self.doorbody, None) # Using the joint to attach door body to environment (None) |
| self.doorslider.setParam(ode.paramFMax, 100) # Sets the force of a motor attached to this joint | self.doorslider.setAxis((-1,0,0)) # Slides down the x-axis |
| </code> The last line here actually attaches a little motor to the joint, which we can give a certain velocity whenever we want to move the joint autonomously. Try replacing the LerpPosInterval calls for opening and closing the door, with calls like this: **''self.doorslider.setParam(ode.paramVel, 0.3)''**, where **0.3** is the velocity (can also be negative to go in the other direction). \\ | self.doorslider.setParamLoStop(0) # Minimum position on the slider |
| - Finally, let's add actual ODE collision handling. Comment out all of the previous collision handling code, since this will completely replace it. In **''World''** constructor, create the following member variable:<code python> | self.doorslider.setParamHiStop(2) # Maximum position on the slider |
| self.contactgroup = ode.JointGroup() # Holds a set of joints | self.doorslider.setParamFMax(50) # Sets the force of a motor attached to this joint |
| </code> Inside the **''simulate''** task, you now have to ask the collision environment to check for near collisions like this:<code python> | </code> The last line here actually attaches a little motor to the joint, which we can give a certain velocity whenever we want to move the joint autonomously. Try replacing the LerpPosInterval calls for opening and closing the door, with calls like this: **''self.doorslider.setParamVel(0.5)''**, where **0.5** is the velocity (can also be negative to go in the other direction). \\ |
| self.space.collide((self.world, self.contactgroup), self.near_callback) | - Finally, make sure to remove all previous collision handling, since ODE will take care of it from now on. Unfortunately, the events generated by the ODE system behave a bit differently than the events created by Panda's collision system, so playing a sound when collision occurs gets tricky. Don't worry about that for now, and enjoy the physical simulation without sounds. |
| </code> Where you then have a new member function called **''near_callback''** that looks like this: <code python> | - For extra excitement try the following: Create an instance of a box every time you press the mouse button. Maintain a list of created boxes in the world and iterate over that list in the simulation function to update their positions and rotations. This way you can fill the scene with tumbling boxes! |
| def near_callback(self, args, solid1, solid2): | |
| contacts = ode.collide(solid1, solid2) # Returns the actual collisions between two solids | |
| world, contactgroup = args | |
| for c in contacts: | |
| c.setBounce(0.2) # How much bounce should happen from this collision | |
| c.setMu(5000) # How much friction there should be between the solids | |
| j = ode.ContactJoint(world, contactgroup, c) # A temporary joint joins the solids together | |
| j.attach(solid1.getBody(), solid2.getBody()) | |
| </code> The very last thing to do is to call **''self.contactgroup.empty()''** right after you have called **''self.world.step(0.04)''** in order to start looking for fresh collisions after each iteration. Test to see if everything is working. \\ | |
| - Play with various simulation values to see what effect they have on the object behavior. You could also try adding more boxes and have them pile on top of each other! | |
