P A R T I C L E S Y S T E M S I N
M U L T I P R O C E S S I N G
A little physics goes a long way.
|
|
|
Examples |
PSystem1
|
|
A particle system is a simple physics model that deals only with point-masses and forces. That means as opposed to rigid-body models, objects in particle systems occupy no volume. Their behavior is quite simple but very powerful. A particle is an object with a location and a mass. It is acted upon by any number of forces. Its acceleration is calculated by f = ma, where f is the vector sum of all the forces acting on it. Particles have three properties that you may want to manipulate: Here is an example of a very simple particle system that attaches two particles by springs to a single fixed particle that follows the mouse when you drag it. A particle system takes small time-steps and updates each particle's location and velocity based on the forces acting on it. The most commonly used forces are gravity, drag, springs, and magnets. Gravity applies a constant additive acceleration to every particle. It can point in any direction and can be turned off. Drag slows the movement of particles. It is equivalent to air-resistance. Springs are forces that exist between two particles that pull the two particles together with a force proportional to the distance of their separation. Networks of particles connected with multiple spring exhibit surprising and lovely behavior. Springs have three parameters: Magnets are forces that attract and repel all particles inversely proportionally to their proximity to the source. Magnets are attached to a particle so that they have a location associated with them and so that they can be conveniently drawn. But the host particle is not affected by its own magnetism. Magnets have one important parameter, their strength.
|
||
Using the particle systems in MultiProcessing |
A simple particle system is built into MultiProcessing. You use it by simply adding particles and forces (primarily springs). The rest will be taken care of by the system. Particles and springs have certain native properties and behaviors which you can change at will.
|
|
Creating a new particle type |
A new particle type is just like a new turtle type in MultiProcessing except that it extends Particle instead of Turtle. All particles automatically have a few properties defined on them. Their position, for instance is updated automatically by the system, and is accessed by the member variable "pos[]" which is an array of three floats. pos[0], pos[1], and pos[2] are the X, Y, and Z positions respectively. Remember that inside the particle's code itself, this variable is just called pos, but outside a particle stored in a variable called particleName, the X position would be accessed this way: particleName.pos[0] The syntax for defining a particle type looks like this: BoxParticle boxPart = new BoxParticle();
class BoxParticle extends Particle {
public BoxParticle() {}
void setup() {
}
void firstLoop() {
}
void loop() {
push();
translate(pos[0], pos[1], pos[2]);
box(5, 5, 5);
pop();
}
}
This defines a simple particle that moves to its position in loop and draws a small box there. This techniqe of push-to-position, draw, and pop is a good model to keep. This way all particles exist in a shared coordinate system, but can draw themselves relative to their own position. To spawn a new particle of this type, you would use the line: spawnParticle(boxPart); You would do this in the same place you might spawn a turtle, like in firstDraw(), and not in too tight a loop. Since particles don't do much other than fall due to gravity without springs or other forces attached, it is likely we want to hold onto a reference to the new particle when we spawn it so we can use it later. Here is an example of two particles being spawned and referenced by variables so that they can be attached by a spring. BoxParticle
a = (BoxParticle)spawnParticle(boxPart, 0, 0, 0); In the above code, we have spawned two particles and stored them in the variables "a" and "b". We have used a variation of the spawn command that also sets the position of the new particle to the values entered. Then we have connected a and b with a spring, which we have assigned to a variable called "s" in case we should decide that we want to modify this spring later.
|
|
A simple collision model based on spherical boundaries is built in. It acts as a strong repelling magnet that is only activated if another particle's radius of collision intersects this particle's radius of collision. These are not like true elastic or inelastic collisions, but it models them well enough to look OK. Collision is turned off by default. In order for two particles to react in collision, collision must be turned on for both particles. This is done using particle.enableCollision(collisionRadius); where collisionRadius is the spherical radius of the particle's collision boundary. Note that this radius may or may not be directly related to how the particle is drawn. You may institute a collision boundary outside the drawn bounds of the particle to act as a force-field. Collision can also be disabled again with particle.disableCollision();
|
||
New functionality |
Particles can do anything that Turtles can do. Here is what has been added to MultiProcessing to support particle systems: gravity(Gy); gravity(Gx,
Gy, Gz); drag(drag); spawnParticle(parent) spawnParticle(parent,
X, Y, Z); particle.setPos(X,
Y, Z); particle.fixed particle.pos particle.mass particle.enableCollision(collisionRadius); particle.disableCollision(); addSpring(particleA,
particleB); addSpring(particleA,
particleB, strength, damping, length); drawSprings(); spring.restLength spring.damping spring.strength defaultSpringStrength(defaultStrength); defaultSpringDamping(defaultDamping); defaultSpringRestLength(defaultRestLength); addMagnet(particleA); addMagnet(particleA,
strength); magnet.strength |
|