Mike's journal

dynamics.pde (a simple pendulum sample - Carl Pearson's new version) // dynamics.pde // // 8 Dec 2010: Sample copied from // http://processing.org/discourse/yabb2/YaBB.pl?num=1267698314 // and ported to the Traer Processingjs library -mrn (Mike Niemi) // 10 Dec 2010: Added a run state indicator -mrn // 12 Dec 2010: Moved Buttons and Traer physics into separate pde files, // added repulsion slider -mrn // 17 Dec 2010: Added fps reading and a button to set frameRate(60) or frameRate(9999) -mrn // 9 Feb 2011: Modified code to use PVector and the convenience classes, // UniversalAttraction and Pulse, simplifying the Pendulums sample // (renamed to dynamics.pde) considerably. -cap (Carl Pearson) int n = 10, kVal = -5; ParticleSystem physics; int SOMEdelay = 300, i0 = 0, pi = -1; boolean justStarting = true, IDE = false; StateButton runStateButton; boolean running = true; HScrollbar hs1; long startMillis = 0, totalCycles = 0, totalMillis = 0; PushButton limitFrameRateButton; int limitingFrameRateState = 0; UniversalAttraction uniAtt; void setup() { size(200,200); smooth(); ellipseMode( CENTER ); physics = new ParticleSystem( 1, 0.05 ); resetModel(); runStateButton = new StateButton(-5, -5, 20, 255, 153, 0); hs1 = new HScrollbar(1, 194, 50, 10, 1); limitFrameRateButton = new PushButton(IDE?105:87, IDE?1:3, IDE?92:70, IDE?13:9, "F.R. Undefined", "F.R. Limited", "F.R. Unlimited"); } void resetModel() { physics.clear(); ArrayList unfixed = new ArrayList(); for (int i=0; i<n; i++) { Particle pend = physics.makeParticle( 1.0, width/2, 25, 0f ); Particle anchor = physics.makeParticle( 1.0, random(10,width-10), height/2-2, 0f ); anchor.makeFixed(); physics.makeSpring( pend, anchor, 0.5, 0.1, 75 ); // Connects anchor to particle unfixed.add(pend); } uniAtt = new UniversalAttraction(kVal, 1, unfixed); physics.addCustomForce(uniAtt); } void calcAttractions(float f1) { kVal = (int)(-5 - f1 * 500.0); // want to go from -5 to -500 uniAtt.setStrength(kVal); } void calcPerturbation(PVector perturbation) { Pulse pul = new Pulse(500, 1, perturbation, 10, physics.particles ); physics.addPulse(pul); } void draw() { i0++; totalCycles++; if (startMillis == 0) startMillis = millis(); if (i0 > SOMEdelay) { // After a while, put our view to sleep to avoid consuming CPU cycles. //println("draw(): going to sleep now"); running = false; noLoop(); } background(0); runStateButton.display( running?runStateButton.STATEon:runStateButton.STATEoff, // Sets the red indicator SOMEdelay-i0 ); // Tempered by how many cycles until we go to sleep limitFrameRateButton.display(limitingFrameRateState); if (hs1.update(SOMEdelay-i0)) // Sometimes the slider does not quiesce automatically when the mouse leaves it. { // The arg causes the slider to turn off its color in sync with the runStateButton. calcAttractions(hs1.getValue()); i0 = 0; } physics.tick(); hs1.display(); fill(128,0,0); text("Repulsion", 4, 198); if ( justStarting && i0>50 ) // Display this text after the 50th cycle when justStarting { float f = 255; if (i0 < 100) f = ((float)i0-50.0)/50.0*255; // 0.0-255.0 .. fade-in the text over 50 cycles fill(f); text("Click on upper half to restart", 25, 40); text("Click on lower half to perturb", 25, 55); text("Move slider to change repulsion", 25, 70); } fill(255); long currMillis = millis(); float f = ((float)totalCycles) *1000.0 / (float)(currMillis - startMillis); f = ((float)((int)(f*1000.0)))/1000.0; // Limit to 3 decimal places text(f, 25, 12); text("fps", IDE?77:67, 12); stroke(255, 200); for (Iterator i = physics.springs.iterator(); i.hasNext(); ) { Spring s = (Spring)i.next(); Particle pend = s.getOneEnd(); Particle anchor = s.getTheOtherEnd(); line( pend.position.x, pend.position.y, anchor.position.x, anchor.position.y ); ellipse( anchor.position.x, anchor.position.y, 5, 5 ); ellipse( pend.position.x, pend.position.y, 20, 20 ); } } void mousePressed() { i0 = 0; justStarting = false; if (!running) // We have just been reawakened startMillis = totalCycles = 0; if (hs1.over()) { running = true; loop(); return; } if (runStateButton.over()) { running = !running; if (running) loop(); // Wake up the view else i0 = SOMEdelay; // let draw() put us to sleep return; } if (limitFrameRateButton.over()) // Undefined > Limited > Unlimited > Limited > ... { switch(limitingFrameRateState) { case 0: limitingFrameRateState=1; frameRate(60); break; case 1: limitingFrameRateState=2; frameRate(9999); break; case 2: limitingFrameRateState=1; frameRate(60); break; default: limitingFrameRateState=2; frameRate(9999); } running = true; loop(); return; } if (mouseY < height/2) { // The mouse is in the upper half - do a reset physics.clear(); if (perturbation != null) perturbation = null; resetModel(); } else { // Otherwise, the mouse is in the lower half - create a new perturbation PVector perturbation = new PVector( mouseX, mouseY, 0f ); calcPerturbation(perturbation); } running = true; loop(); // Wake up the view (if not already awake) }

traer3a.pde (the Traer physics library, ported to Processing.js - with Carl Pearson's improvements) // Traer Physics 3.0 // Terms from Traer's download page, http://traer.cc/mainsite/physics/ // LICENSE - Use this code for whatever you want, just send me a link jeff@traer.cc // // traer3a.pde // From traer.physics - author: Jeff Traer // Attraction Particle // EulerIntegrator ParticleSystem // Force RungeKuttaIntegrator // Integrator Spring // ModifiedEulerIntegrator Vector3D // // From traer.animator - author: Jeff Traer // Smoother // Smoother3D // Tickable // // New - author: Carl Pearson // UniversalAttraction // Pulse // // 13 Dec 2010: Copied 3.0 src from http://traer.cc/mainsite/physics/ and ported to Processingjs, // added makeParticle2(), makeAttraction2(), replaceAttraction(), and removeParticle(int) -mrn (Mike Niemi) // 9 Feb 2011: Fixed bug in Euler integrators where they divided by time instead of // multiplying by it in the update steps, // eliminated the Vector3D class (converting the code to use the native PVector class), // did some code compaction in the RK solver, // added a couple convenience classes, UniversalAttraction and Pulse, simplifying // the Pendulums sample (renamed to dynamics.pde) considerably. -cap (Carl Pearson) //=========================================================================================== // Attraction //=========================================================================================== // attract positive repel negative //package traer.physics; public class Attraction implements Force { Particle one; Particle b; float k; boolean on = true; float distanceMin; float distanceMinSquared; public Attraction( Particle a, Particle b, float k, float distanceMin ) { this.one = a; this.b = b; this.k = k; this.distanceMin = distanceMin; this.distanceMinSquared = distanceMin*distanceMin; } protected void setA( Particle p ) { one = p; } protected void setB( Particle p ) { b = p; } public final float getMinimumDistance() { return distanceMin; } public final void setMinimumDistance( float d ) { distanceMin = d; distanceMinSquared = d*d; } public final void turnOff() { on = false; } public final void turnOn() { on = true; } public final void setStrength( float k ) { this.k = k; } public final Particle getOneEnd() { return one; } public final Particle getTheOtherEnd() { return b; } public void apply() { if ( on && ( one.isFree() || b.isFree() ) ) { PVector a2b = PVector.sub(one.position, b.position, new PVector()); float a2bDistanceSquared = a2b.dot(a2b); if ( a2bDistanceSquared < distanceMinSquared ) a2bDistanceSquared = distanceMinSquared; float force = k * one.mass0 * b.mass0 / (a2bDistanceSquared * (float)Math.sqrt(a2bDistanceSquared)); a2b.mult( force ); // apply if ( b.isFree() ) b.force.add( a2b ); if ( one.isFree() ) { a2b.mult(-1f); one.force.add( a2b ); } } } public final float getStrength() { return k; } public final boolean isOn() { return on; } public final boolean isOff() { return !on; } } // Attraction //=========================================================================================== // UniversalAttraction //=========================================================================================== // attract positive repel negative public class UniversalAttraction implements Force { public UniversalAttraction( float k, float distanceMin, ArrayList targetList ) { this.k = k; this.distanceMin = distanceMin; this.distanceMinSquared = distanceMin*distanceMin; this.targetList = targetList; } float k; boolean on = true; float distanceMin; float distanceMinSquared; ArrayList targetList; public final float getMinimumDistance() { return distanceMin; } public final void setMinimumDistance( float d ) { distanceMin = d; distanceMinSquared = d*d; } public final void turnOff() { on = false; } public final void turnOn() { on = true; } public final void setStrength( float k ) { this.k = k; } public final float getStrength() { return k; } public final boolean isOn() { return on; } public final boolean isOff() { return !on; } public void apply() { if ( on ) { for (int i=0; i < targetList.size(); i++ ) { for (int j=i+1; j < targetList.size(); j++) { Particle a = (Particle)targetList.get(i); Particle b = (Particle)targetList.get(j); if ( a.isFree() || b.isFree() ) { PVector a2b = PVector.sub(a.position, b.position, new PVector()); float a2bDistanceSquared = a2b.dot(a2b); if ( a2bDistanceSquared < distanceMinSquared ) a2bDistanceSquared = distanceMinSquared; float force = k * a.mass0 * b.mass0 / (a2bDistanceSquared * (float)Math.sqrt(a2bDistanceSquared)); a2b.mult( force ); if ( b.isFree() ) b.force.add( a2b ); if ( a.isFree() ) { a2b.mult(-1f); a.force.add( a2b ); } } } } } } } //UniversalAttraction //=========================================================================================== // Pulse //=========================================================================================== public class Pulse implements Force { public Pulse( float k, float distanceMin, PVector origin, float lifetime, ArrayList targetList ) { this.k = k; this.distanceMin = distanceMin; this.distanceMinSquared = distanceMin*distanceMin; this.origin = origin; this.targetList = targetList; this.lifetime = lifetime; } float k; boolean on = true; float distanceMin; float distanceMinSquared; float lifetime; PVector origin; ArrayList targetList; public final void turnOff() { on = false; } public final void turnOn() { on = true; } public final boolean isOn() { return on; } public final boolean isOff() { return !on; } public final boolean tick( float time ) { lifetime-=time; if (lifetime <= 0f) turnOff(); return on; } public void apply() { if (on) { PVector holder = new PVector(); int count = 0; for (Iterator i = targetList.iterator(); i.hasNext(); ) { Particle p = (Particle)i.next(); if ( p.isFree() ) { holder.set( p.position.x, p.position.y, p.position.z ); holder.sub( origin ); float distanceSquared = holder.dot(holder); if (distanceSquared < distanceMinSquared) distanceSquared = distanceMinSquared; holder.mult(k / (distanceSquared * (float)Math.sqrt(distanceSquared)) ); p.force.add( holder ); } } } } }//Pulse //=========================================================================================== // EulerIntegrator //=========================================================================================== //package traer.physics; public class EulerIntegrator implements Integrator { ParticleSystem s; public EulerIntegrator( ParticleSystem s ) { this.s = s; } public void step( float t ) { s.clearForces(); s.applyForces(); for ( Iterator i = s.particles.iterator(); i.hasNext(); ) { Particle p = (Particle)i.next(); if ( p.isFree() ) { p.velocity.add( PVector.mult(p.force, t/p.mass0) ); p.position.add( PVector.mult(p.velocity, t) ); } } } } // EulerIntegrator //=========================================================================================== // Force //=========================================================================================== // May 29, 2005 //package traer.physics; // @author jeffrey traer bernstein public interface Force { public void turnOn(); public void turnOff(); public boolean isOn(); public boolean isOff(); public void apply(); } // Force //=========================================================================================== // Integrator //=========================================================================================== //package traer.physics; public interface Integrator { public void step( float t ); } // Integrator //=========================================================================================== // ModifiedEulerIntegrator //=========================================================================================== //package traer.physics; public class ModifiedEulerIntegrator implements Integrator { ParticleSystem s; public ModifiedEulerIntegrator( ParticleSystem s ) { this.s = s; } public void step( float t ) { s.clearForces(); s.applyForces(); float halft = 0.5f*t; PVector a = new PVector(); PVector holder = new PVector(); for ( int i = 0; i < s.numberOfParticles(); i++ ) { Particle p = s.getParticle( i ); if ( p.isFree() ) { PVector.div(p.force, p.mass0, a); p.position.add( PVector.mult(p.velocity, t, holder) ); p.velocity.add( PVector.mult(a, t, a) ); p.position.add( PVector.mult(a, halft, a) ); } } } } // ModifiedEulerIntegrator //=========================================================================================== // Particle //=========================================================================================== //package traer.physics; public class Particle { PVector position = new PVector(); PVector velocity = new PVector(); PVector force = new PVector(); protected float mass0; protected float age0 = 0; protected boolean dead0 = false; boolean fixed0 = false; public Particle( float m ) { mass0 = m; } // @see traer.physics.AbstractParticle#distanceTo(traer.physics.Particle) public final float distanceTo( Particle p ) { return this.position.dist( p.position ); } // @see traer.physics.AbstractParticle#makeFixed() public final Particle makeFixed() { fixed0 = true; velocity.set(0f,0f,0f); force.set(0f, 0f, 0f); return this; } // @see traer.physics.AbstractParticle#makeFree() public final Particle makeFree() { fixed0 = false; return this; } // @see traer.physics.AbstractParticle#isFixed() public final boolean isFixed() { return fixed0; } // @see traer.physics.AbstractParticle#isFree() public final boolean isFree() { return !fixed0; } // @see traer.physics.AbstractParticle#mass() public final float mass() { return mass0; } // @see traer.physics.AbstractParticle#setMass(float) public final void setMass( float m ) { mass0 = m; } // @see traer.physics.AbstractParticle#age() public final float age() { return age0; } protected void reset() { age0 = 0; dead0 = false; position.set(0f,0f,0f); velocity.set(0f,0f,0f); force.set(0f,0f,0f); mass0 = 1f; } } // Particle //=========================================================================================== // ParticleSystem //=========================================================================================== // May 29, 2005 //package traer.physics; //import java.util.*; public class ParticleSystem { public static final int RUNGE_KUTTA = 0; public static final int MODIFIED_EULER = 1; protected static final float DEFAULT_GRAVITY = 0; protected static final float DEFAULT_DRAG = 0.001f; ArrayList particles = new ArrayList(); ArrayList springs = new ArrayList(); ArrayList attractions = new ArrayList(); ArrayList customForces = new ArrayList(); ArrayList pulses = new ArrayList(); Integrator integrator; PVector gravity = new PVector(); float drag; boolean hasDeadParticles = false; public final void setIntegrator( int which ) { switch ( which ) { case RUNGE_KUTTA: this.integrator = new RungeKuttaIntegrator( this ); break; case MODIFIED_EULER: this.integrator = new ModifiedEulerIntegrator( this ); break; } } public final void setGravity( float x, float y, float z ) { gravity.set( x, y, z ); } // default down gravity public final void setGravity( float g ) { gravity.set( 0, g, 0 ); } public final void setDrag( float d ) { drag = d; } public final void tick() { tick( 1 ); } public final void tick( float t ) { integrator.step( t ); for (int i = 0; i<pulses.size(); ) { Pulse p = (Pulse)pulses.get(i); p.tick(t); if (p.isOn()) { i++; } else { pulses.remove(i); } } if (pulses.size()!=0) for (Iterator i = pulses.iterator(); i.hasNext(); ) { Pulse p = (Pulse)(i.next()); p.tick( t ); if (!p.isOn()) i.remove(); } } public final Particle makeParticle( float mass, float x, float y, float z ) { Particle p = new Particle( mass ); p.position.set( x, y, z ); particles.add( p ); return p; } public final int makeParticle2( float mass, float x, float y, float z ) { // mrn makeParticle(mass, x, y, z); return particles.size()-1; } public final Particle makeParticle() { return makeParticle( 1.0f, 0f, 0f, 0f ); } public final Spring makeSpring( Particle a, Particle b, float ks, float d, float r ) { Spring s = new Spring( a, b, ks, d, r ); springs.add( s ); return s; } public final Attraction makeAttraction( Particle first, Particle b, float k, float minDistance ) { Attraction m = new Attraction( first, b, k, minDistance ); attractions.add( m ); return m; } public final int makeAttraction2( Particle a, Particle b, float k, float minDistance ) { // mrn makeAttraction(a, b, k, minDistance); return attractions.size()-1; // return the index } public final void replaceAttraction( int i, Attraction m ) { // mrn attractions.set( i, m ); } public final void addPulse(Pulse pu){ pulses.add(pu); } public final void clear() { particles.clear(); springs.clear(); attractions.clear(); customForces.clear(); pulses.clear(); } public ParticleSystem( float g, float somedrag ) { setGravity( 0f, g, 0f ); drag = somedrag; integrator = new RungeKuttaIntegrator( this ); } public ParticleSystem( float gx, float gy, float gz, float somedrag ) { setGravity( gx, gy, gz ); drag = somedrag; integrator = new RungeKuttaIntegrator( this ); } public ParticleSystem() { setGravity( 0f, ParticleSystem.DEFAULT_GRAVITY, 0f ); drag = ParticleSystem.DEFAULT_DRAG; integrator = new RungeKuttaIntegrator( this ); } protected final void applyForces() { if ( gravity.mag() != 0f ) { for ( Iterator i = particles.iterator(); i.hasNext(); ) { Particle p = (Particle)i.next(); if (p.isFree()) p.force.add( gravity ); } } PVector target = new PVector(); for ( Iterator i = particles.iterator(); i.hasNext(); ) { Particle p = (Particle)i.next(); if (p.isFree()) p.force.add( PVector.mult(p.velocity, -drag, target) ); } applyAll(springs); applyAll(attractions); applyAll(customForces); applyAll(pulses); } private void applyAll(ArrayList forces) { if( forces.size()!=0 ) for ( Iterator i = forces.iterator(); i.hasNext(); ) ((Force)i.next()).apply(); } protected final void clearForces() { for (Iterator i = particles.iterator(); i.hasNext(); ) ((Particle)i.next()).force.set(0f, 0f, 0f); } public final int numberOfParticles() { return particles.size(); } public final int numberOfSprings() { return springs.size(); } public final int numberOfAttractions() { return attractions.size(); } public final Particle getParticle( int i ) { return (Particle)particles.get( i ); } public final Spring getSpring( int i ) { return (Spring)springs.get( i ); } public final Attraction getAttraction( int i ) { return (Attraction)attractions.get( i ); } public final void addCustomForce( Force f ) { customForces.add( f ); } public final int numberOfCustomForces() { return customForces.size(); } public final Force getCustomForce( int i ) { return (Force)customForces.get( i ); } public final Force removeCustomForce( int i ) { return (Force)customForces.remove( i ); } public final void removeParticle( int i ) { particles.remove( i ); } //mrn public final void removeParticle( Particle p ) { particles.remove( p ); } public final Spring removeSpring( int i ) { return (Spring)springs.remove( i ); } public final Attraction removeAttraction( int i ) { return (Attraction)attractions.remove( i ); } public final void removeAttraction( Attraction s ) { attractions.remove( s ); } public final void removeSpring( Spring a ) { springs.remove( a ); } public final void removeCustomForce( Force f ) { customForces.remove( f ); } } // ParticleSystem //=========================================================================================== // RungeKuttaIntegrator //=========================================================================================== //package traer.physics; //import java.util.*; public class RungeKuttaIntegrator implements Integrator { ArrayList originalPositions = new ArrayList(); ArrayList originalVelocities = new ArrayList(); ArrayList k1Forces = new ArrayList(); ArrayList k1Velocities = new ArrayList(); ArrayList k2Forces = new ArrayList(); ArrayList k2Velocities = new ArrayList(); ArrayList k3Forces = new ArrayList(); ArrayList k3Velocities = new ArrayList(); ArrayList k4Forces = new ArrayList(); ArrayList k4Velocities = new ArrayList(); ParticleSystem s; public RungeKuttaIntegrator( ParticleSystem s ) { this.s = s; } final void allocateParticles() { while( s.particles.size() > originalPositions.size() ) { originalPositions.add( new PVector() ); originalVelocities.add( new PVector() ); k1Forces.add( new PVector() ); k1Velocities.add( new PVector() ); k2Forces.add( new PVector() ); k2Velocities.add( new PVector() ); k3Forces.add( new PVector() ); k3Velocities.add( new PVector() ); k4Forces.add( new PVector() ); k4Velocities.add( new PVector() ); } } private final void setIntermediate(ArrayList forces, ArrayList velocities) { s.applyForces(); for ( int i = 0; i < s.particles.size(); ++i ) { Particle p = (Particle)s.particles.get( i ); if ( p.isFree() ) { ((PVector)forces.get( i )).set( p.force.x, p.force.y, p.force.z ); ((PVector)velocities.get( i )).set( p.velocity.x, p.velocity.y, p.velocity.z ); p.force.set(0f,0f,0f); } } } private final void updateIntermediate(ArrayList forces, ArrayList velocities, float multiplier) { PVector holder = new PVector(); for ( int i = 0; i < s.particles.size(); ++i ) { Particle p = (Particle)s.particles.get( i ); if ( p.isFree() ) { PVector op = (PVector)(originalPositions.get( i )); p.position.set(op.x, op.y, op.z); p.position.add(PVector.mult((PVector)(velocities.get( i )), multiplier, holder)); PVector ov = (PVector)(originalVelocities.get( i )); p.velocity.set(ov.x, ov.y, ov.z); p.velocity.add(PVector.mult((PVector)(forces.get( i )), multiplier/p.mass0, holder)); } } } private final void initialize() { for ( int i = 0; i < s.particles.size(); ++i ) { Particle p = (Particle)(s.particles.get( i )); if ( p.isFree() ) { ((PVector)(originalPositions.get( i ))).set( p.position.x, p.position.y, p.position.z ); ((PVector)(originalVelocities.get( i ))).set( p.velocity.x, p.velocity.y, p.velocity.z ); } p.force.set(0f,0f,0f); // and clear the forces } } public final void step( float deltaT ) { allocateParticles(); initialize(); setIntermediate(k1Forces, k1Velocities); updateIntermediate(k1Forces, k1Velocities, 0.5f*deltaT ); setIntermediate(k2Forces, k2Velocities); updateIntermediate(k2Forces, k2Velocities, 0.5f*deltaT ); setIntermediate(k3Forces, k3Velocities); updateIntermediate(k3Forces, k3Velocities, deltaT ); setIntermediate(k4Forces, k4Velocities); ///////////////////////////////////////////////////////////// // put them all together and what do you get? for ( int i = 0; i < s.particles.size(); ++i ) { Particle p = (Particle)s.particles.get( i ); p.age0 += deltaT; if ( p.isFree() ) { // update position PVector holder = (PVector)(k2Velocities.get( i )); holder.add((PVector)k3Velocities.get( i )); holder.mult(2.0f); holder.add((PVector)k1Velocities.get( i )); holder.add((PVector)k4Velocities.get( i )); holder.mult(deltaT / 6.0f); holder.add((PVector)originalPositions.get( i )); p.position.set(holder.x, holder.y, holder.z); // update velocity holder = (PVector)k2Forces.get( i ); holder.add((PVector)k3Forces.get( i )); holder.mult(2.0f); holder.add((PVector)k1Forces.get( i )); holder.add((PVector)k4Forces.get( i )); holder.mult(deltaT / (6.0f * p.mass0 )); holder.add((PVector)originalVelocities.get( i )); p.velocity.set(holder.x, holder.y, holder.z); } } } } // RungeKuttaIntegrator //=========================================================================================== // Spring //=========================================================================================== // May 29, 2005 //package traer.physics; // @author jeffrey traer bernstein public class Spring implements Force { float springConstant0; float damping0; float restLength0; Particle one, b; boolean on = true; public Spring( Particle A, Particle B, float ks, float d, float r ) { springConstant0 = ks; damping0 = d; restLength0 = r; one = A; b = B; } public final void turnOff() { on = false; } public final void turnOn() { on = true; } public final boolean isOn() { return on; } public final boolean isOff() { return !on; } public final Particle getOneEnd() { return one; } public final Particle getTheOtherEnd() { return b; } public final float currentLength() { return one.distanceTo( b ); } public final float restLength() { return restLength0; } public final float strength() { return springConstant0; } public final void setStrength( float ks ) { springConstant0 = ks; } public final float damping() { return damping0; } public final void setDamping( float d ) { damping0 = d; } public final void setRestLength( float l ) { restLength0 = l; } public final void apply() { if ( on && ( one.isFree() || b.isFree() ) ) { PVector a2b = PVector.sub(one.position, b.position, new PVector()); float a2bDistance = a2b.mag(); if (a2bDistance!=0f) { a2b.div(a2bDistance); } // spring force is proportional to how much it stretched float springForce = -( a2bDistance - restLength0 ) * springConstant0; PVector vDamping = PVector.sub(one.velocity, b.velocity, new PVector()); float dampingForce = -damping0 * a2b.dot(vDamping); // forceB is same as forceA in opposite direction float r = springForce + dampingForce; a2b.mult(r); if ( one.isFree() ) one.force.add( a2b ); if ( b.isFree() ) b.force.add( PVector.mult(a2b, -1, a2b) ); } } protected void setA( Particle p ) { one = p; } protected void setB( Particle p ) { b = p; } } // Spring //=========================================================================================== // Smoother //=========================================================================================== //package traer.animator; public class Smoother implements Tickable { public Smoother(float smoothness) { setSmoothness(smoothness); setValue(0.0F); } public Smoother(float smoothness, float start) { setSmoothness(smoothness); setValue(start); } public final void setSmoothness(float smoothness) { a = -smoothness; gain = 1.0F + a; } public final void setTarget(float target) { input = target; } public void setValue(float x) { input = x; lastOutput = x; } public final float getTarget() { return input; } public final void tick() { lastOutput = gain * input - a * lastOutput; } public final float getValue() { return lastOutput; } public float a, gain, lastOutput, input; } // Smoother //=========================================================================================== // Smoother3D //=========================================================================================== //package traer.animator; public class Smoother3D implements Tickable { public Smoother3D(float smoothness) { x0 = new Smoother(smoothness); y0 = new Smoother(smoothness); z0 = new Smoother(smoothness); } public Smoother3D(float initialX, float initialY, float initialZ, float smoothness) { x0 = new Smoother(smoothness, initialX); y0 = new Smoother(smoothness, initialY); z0 = new Smoother(smoothness, initialZ); } public final void setXTarget(float X) { x0.setTarget(X); } public final void setYTarget(float X) { y0.setTarget(X); } public final void setZTarget(float X) { z0.setTarget(X); } public final float getXTarget() { return x0.getTarget(); } public final float getYTarget() { return y0.getTarget(); } public final float getZTarget() { return z0.getTarget(); } public final void setTarget(float X, float Y, float Z) { x0.setTarget(X); y0.setTarget(Y); z0.setTarget(Z); } public final void setValue(float X, float Y, float Z) { x0.setValue(X); y0.setValue(Y); z0.setValue(Z); } public final void setX(float X) { x0.setValue(X); } public final void setY(float Y) { y0.setValue(Y); } public final void setZ(float Z) { z0.setValue(Z); } public final void setSmoothness(float smoothness) { x0.setSmoothness(smoothness); y0.setSmoothness(smoothness); z0.setSmoothness(smoothness); } public final void tick() { x0.tick(); y0.tick(); z0.tick(); } public final float x() { return x0.getValue(); } public final float y() { return y0.getValue(); } public final float z() { return z0.getValue(); } public Smoother x0, y0, z0; } // Smoother3D //=========================================================================================== // Tickable //=========================================================================================== //package traer.animator; public interface Tickable { public abstract void tick(); public abstract void setSmoothness(float f); } // Tickable

widgets.pde (buttons for the pendulum sample) // widgets.pde // Button // PushButton // StateButton // StartPauseStopButton // RestartButton // HScrollbar // // Last updated: 17 Dec 2010, -mrn (Mike Niemi) class Button { int x, y, buttonSize, ibackgroundcolor, ihighlightcolor, ibasecolor; color currentcolor; boolean over0 = false, pressed0 = false, locked0 = false; void update() { if (over()) currentcolor = color(ihighlightcolor); else currentcolor = color(ibasecolor); } boolean pressed() { if (over0) { locked0 = true; return true; } else { locked0 = false; return false; } } boolean over() { return true; } boolean overRect(int x, int y, int width, int height) { if (mouseX >= x && mouseX <= x+width && mouseY >= y && mouseY <= y+height) return true; else return false; } boolean overCircle(int x, int y, int diameter) { float disX = x - mouseX; float disY = y - mouseY; if (sqrt(sq(disX) + sq(disY)) < diameter/2 ) return true; else return false; } boolean overArc(int x, int y, int width, int height) { if (mouseX >= x && mouseX <= x+width && mouseY >= (y-height/2) && mouseY <= (y-height/2)+height) return true; else return false; } } // Button class PushButton extends Button { int buttonWidth, buttonHeight; String s[] = new String[3]; PushButton(int ix, int iy, int iWidth, int iHeight, String text0, String text1, String text2) { x = ix; // x and y are the upper left corner (like ellipseMode(CORNER)) y = iy; buttonHeight = iHeight; buttonWidth = iWidth; s[0] = text0; s[1] = text1; s[2] = text2; } boolean over() { if ( overRect(x, y, buttonWidth, buttonHeight) ) { over0 = true; return true; } else { over0 = false; return false; } } void display(int state) // e.g. Undefined, Limited, Unlimited { switch(state) { case(0): fill(100); break; case(1): fill(100,0,0); break; default: fill(0,100,0); } rect(x, y, buttonWidth, buttonHeight); fill(255); text(s[state], x+1, y+buttonHeight-1); } } class StateButton extends Button { final static int STATEoff = 0, STATEon = 1; int cx, cy; StateButton(int ix, int iy, int isize, int icolor, int ihighlight, int ibackground) { x = ix; // x and y are the upper left corner (like ellipseMode(CORNER)) y = iy; buttonSize = isize; cx = x + buttonSize/2; // cx and cy will be the center cy = y + buttonSize/2; ibasecolor = icolor; ihighlightcolor = ihighlight; currentcolor = color(ibasecolor); ibackgroundcolor = ibackground; } boolean over() { if ( overCircle(cx, cy, buttonSize) ) { over0 = true; return true; } else { over0 = false; return false; } } void display(int state, int numCyclesLeft) { if (state == STATEon) { stroke(128); if (numCyclesLeft < 20) // fade in the idled color { float f0 = 1.0 - ((float)numCyclesLeft)/20.0; // 0.0 - 1.0 float f1 = ibasecolor - f0 * (float)(ibasecolor-ibackgroundcolor); if (ibackgroundcolor == 0) fill(f1,0,0); else { float f2 = f0 * 255.0; fill(f1,f2,f2); } } else fill(ibasecolor,0,0); ellipse(cx, cy, buttonSize, buttonSize); } else { stroke(128); fill(color(ibackgroundcolor)); ellipse(cx, cy, buttonSize, buttonSize); } } } // StateButton class StartPauseStopButton extends Button { final static int SHOWrun = 0, SHOWpause = 1, SHOWstop = 2; StartPauseStopButton(int ix, int iy, int isize, int icolor, int ihighlight, int ibackground) { x = ix; // x and y are the upper left corner y = iy; buttonSize = isize; ibasecolor = icolor; ihighlightcolor = ihighlight; currentcolor = color(ibasecolor); ibackgroundcolor = ibackground; } boolean over() { if ( overRect(x, y, buttonSize, buttonSize) ) { over0 = true; return true; } else { over0 = false; return false; } } void display(int whatToShow) { if (whatToShow == SHOWstop) { stroke(255, 80, 80); fill(255,0,0); rect(x, y, buttonSize, buttonSize); } else if (whatToShow == SHOWpause) { stroke(128); fill(0); rect(x+2, y, buttonSize/4, buttonSize); rect(x+2*buttonSize/3-2, y, buttonSize/4, buttonSize); } else if (whatToShow == SHOWrun) { stroke(80, 255, 80); fill(0,255,0); triangle(x,y, x+buttonSize,y+buttonSize/2, x,y+buttonSize); } } } // StartPauseStopButton class RestartButton extends Button { int cx, cy; RestartButton(int ix, int iy, int isize, int icolor, int ihighlight, int ibackground) { x = ix; // x and y are the upper left corner y = iy; buttonSize = isize; cx = x + buttonSize/2; // cx and cy will be the center cy = y + buttonSize/2; ibasecolor = icolor; ihighlightcolor = ihighlight; currentcolor = color(ibasecolor); ibackgroundcolor = ibackground; } boolean over() { if ( overCircle(cx, cy, buttonSize) ) { over0 = true; return true; } else { over0 = false; return false; } } void display() { stroke(0); noFill(); arc(cx, cy, buttonSize, buttonSize, PI/2, 2*PI); arc(cx, cy, buttonSize-10, buttonSize-10, PI/2, 2*PI); line(x+buttonSize-3, cy+5, x+buttonSize+4, cy-3); line(x+buttonSize-3, cy+5, x+buttonSize-10, cy-3); line(cx, y+buttonSize-4, cx, y+buttonSize); } } // RestartButton class HScrollbar { int swidth, sheight; // width and height of bar int xpos, ypos; // x and y position of bar float spos, newspos; // x position of slider int sposMin, sposMax; // max and min values of slider int loose; // how loose/heavy boolean over0; // is the mouse over the slider? boolean locked0; float ratio; int cyclesLeft = 9999; HScrollbar (int xp, int yp, int sw, int sh, int l) { swidth = sw; sheight = sh; int widthtoheight = sw - sh; ratio = (float)sw / (float)widthtoheight; xpos = xp; ypos = yp-sheight/2; //spos = xpos + swidth/2 - sheight/2; spos = xpos; newspos = spos; sposMin = xpos; sposMax = xpos + swidth - sheight; loose = l; } boolean update(int i) { float oldNewspos = newspos; cyclesLeft = i; if (over()) over0 = true; else over0 = false; if (mousePressed && over0) locked0 = true; if (!mousePressed) locked0 = false; if (locked0) newspos = constrain(mouseX-sheight/2, sposMin, sposMax); if (abs(newspos - spos) > 1) spos = spos + (newspos-spos)/loose; return ( oldNewspos != newspos ); } int constrain (int val, int minv, int maxv) { return min(max(val, minv), maxv); } boolean over() { over0 = (mouseX > xpos && mouseX < xpos+swidth && mouseY > ypos && mouseY < ypos+sheight); return over0; } boolean locked() { locked0 = over0 && mousePressed; return locked0; } void display() { fill(255); rect(xpos, ypos, swidth, sheight); boolean quiescing = false; if ( cyclesLeft < 50 ) { if (over0 || locked0) { float f = ((float)cyclesLeft)/50.0; // 1.0-0.0 .. fade-out over 50 cycles f = 102 + f*(200-102); fill(f,102,0); quiescing = true; } } if (!quiescing) { if (over0 || locked0) fill(200, 102, 0); else fill(102, 102, 102); } rect(spos, ypos, sheight, sheight); } float getPos() { return spos * ratio; } // 0 - total width of the scrollbar float getValue() { return (newspos-xpos)/(swidth-sheight); } // 0.0 - 1.0 } // HScrollbar

dynamics.html (a sample html file) <html> <!-- A sample HTML file. -- -- Copy to your webserver and change dir1 -- -- and dir2 (in 3 places) accordingly. --> <head> <script language=JavaScript src="/dir1/processing-1.0.0.js" type=text/javascript></script> </head> <body> <canvas id="sketch" data-processing-sources="/dir2/dynamics/dynamics.pde /dir2/dynamics/traer3a.pde /dir2/dynamics/widgets.pde"></canvas> </body> </html>