Physics Programming Assignment
Due: March 14th (signs of life due March 7th, project plan due March 3rd)
Overview
The idea of this project is to give you a chance to experiment with doing some physics programming. Since there isn't much time, and we haven't talked about too much physical simulation, what you can do is kindof limited.
You can choose what you want to do. We will provide some suggestions, and have a discussion in class about what is (or isn't) implementable in this kind of time frame.
The project will unfold in 3 stages
- you need to tell us what you want to do, so we can make sure your level of ambition is correct (proposal, due March 3rd)
- you need to show us something that indicates that you've actually started (signs of life, due March 7th)
- you turn in a final project, including (possibly) giving a demo and doing some written work
Your project needs to do a few things:
- there must be (at least) particles in (at least) 2D
- you need to solve ODEs for the equations of motions
- you need to have particles, springs and gravity
- you need to have some kind of collision detection and response
(note: 3 and 4 might be distinct. the particles connected by springs might be independent of objects that collide)
Some Ground Rules
You will work with a partner who is assigned to you. The assigned pairings are:
- Hanson & Driscoll
- Kruse & Geil
Sirivong
- Leaf & Lynde
- Park & Moore
- Byrne & Felder & Brzycki
Games Strommen & Steinich
(one person is not on this list, but he knows who he is and we're doing something about it)
You may work in any programming language, providing your program can be compiled and run in 1358 (or you make an alternate arrangement)
If you want to use an outside library, ask first. If you use something that does a bunch of the work for you (like a physics engine), we'll change the nature of the assignment around that.
Things that you have to do
You need to create a world with objects in it, and to have these objects react to forces from the outside (and with one another).
You must be able to compute at a fixed frame rate. This will probably be de-coupled from your simulation steps. (for instance you might compute 10 simulation steps with a fixed time step, and then wait until 1/30 of a second is up before continuing).
One demo you must be able to give: simulate a chain/string hanging from one end, waving under the influence of gravity. You will probably model this as a bunch of particles connected by springs. Experiment with how long of a chain you can simulate, how stiff you can make it, and what effects having damping might have. You might experiment with methods to enhance the stability as the system gets stiffer. (a big objective here is to give you some experience with what stiffness is, and how it might be counteracted)
Also, your demos must include some kind of collision detection/response. You might just have it so that your particles bounce off the edge of the screen. Or you might implement collision detection and response for a more interesting class of objects. What is required is that there is evidence of collisions.
Remember, this is the minimum: to get a good grade, you have to go beyond this. Here are some ideas:
- allow the user to make arbitrary connections between points to build "gadgets" by connecting pieces with springs and motors. (you can think of all kinds of force sources to add)
- give your particles some size (make them circles) and allow them to collide with one another. to make the circle collisions challenging you might add:
- exact collision detection (figure out the exact point of contact, by backing up the simulation) - possibly including checks to make sure things don't pass through one another
- resting contact - have a single moving circle that drops until it hits something, and then have it "roll" until it finds a stable configuration
- the ability to do lots of particles (potentially in 3D) to make "blobby fountains" (e.g. simulate water as a collection of particles that repel one another)
- allow for complex shapes (polygons in 2D) and do collision detection between them. doing proper collision response would be a bit harder (since you have to deal with the moments of the impulses)
- you could make a "tetris-like" "game" where you have to drop a pile of polygons, they keep dropping until they hit something (exact collision detection) and then they stop. (there's no real "physics" here - your springy particles would be pretty independent)
- implement a constraint model (better than springs) to give your "springs" more stiffness
- use penalty collisions to "push-out" points that cross springs (so you have little springy triangles that bounce into one another)
These things have various amounts of challenge added - you will be rewarded (with a good grade) for getting challenging things to work.
Think of what you want to do, and discuss it with the professor - we'll find something for everyone!
Some things NOT to do
- 3D rigid bodies (we don't want to deal with rotations in 3D yet)
- Multi-point resting contact (i.e. the Baraf quadratic programming stuff) - no way to pull this off in the limited time
- particle fireworks - the particles need to interact for this to be interesting (although, you can make fountains where the particles collide)
Some notes on turning things in:
Project proposal:
- you should send email to the professor and TA before the deadline, describing what you are going to do.
- your project proposal isn't "accepted" until you receive mail back from the professor saying it is - we might ask you to refine your plan
Signs of Life:
- On the AllStudents.PhysicsProjects page, put a link to a page (preferably in one group memeber's PageGroup) describing what you have gotten working, and a picture of what your system looks like.
- You should have (at least) some particles whose movement is computed as the solution to an ODE.
Final Project:
- The code (demoable portion) is due in class on March 14th. We'll do live demos in class.
- The final project is due before break. If you don't want to give your demo the Friday before break (because you want to head out early or something), you need to make an arrangement ahead of time.
- The writeup, and turning in the code is due by 11:59pm on March 14th. Late assignments will be penalized.
- Make a ZIP file with everything we need to build your program, as well as instructions on how to build it. Put it in the pub directory, and link to it from your documentation.
- You should make a page (preferably in one team member's page group) that documents the project (explain what it does and how). You should link to this page from the AllStudents.PhysicsProjects.
- In your documentation, be sure to discuss:
- What type of ODE solvers you have tried
- Any experimentation that you've done (and you should have done some) on combatting stiffness: what are the tradeoffs between damping, (apparent) rigidity, solution methods, ....
- How you are doing collision detection and response
- How your system would scale (to more objects, more dense collections, stiffer objects, less bouncy collisions, ...)
