toxiclibs 0.9.2 → 2.1.0

data/src/main/java/toxi/physics2d/VerletPhysics2D.java

@@ -0,0 +1,440 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * Copyright (c) 2006-2011 Karsten Schmidt
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * http://creativecommons.org/licenses/LGPL/2.1/
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+package toxi.physics2d;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import toxi.geom.Rect;
+import toxi.geom.SpatialIndex;
+import toxi.geom.Vec2D;
+import toxi.physics2d.behaviors.GravityBehavior2D;
+import toxi.physics2d.behaviors.ParticleBehavior2D;
+import toxi.physics2d.constraints.ParticleConstraint2D;
+
+/**
+ * 3D particle physics engine using Verlet integration based on:
+ * http://en.wikipedia.org/wiki/Verlet_integration
+ * http://www.teknikus.dk/tj/gdc2001.htm
+ *
+ */
+public class VerletPhysics2D {
+
+  /**
+   *
+   * @param c
+   * @param list
+   */
+  public static void addConstraintToAll(ParticleConstraint2D c,
+    List<VerletParticle2D> list) {
+    list.forEach((p) -> {
+      p.addConstraint(c);
+    });
+  }
+
+  /**
+   *
+   * @param c
+   * @param list
+   */
+  public static void removeConstraintFromAll(ParticleConstraint2D c,
+    List<VerletParticle2D> list) {
+    list.forEach((p) -> {
+      p.removeConstraint(c);
+    });
+  }
+
+  /**
+   * List of particles
+   */
+  public ArrayList<VerletParticle2D> particles;
+
+  /**
+   * List of spring/stick connectors
+   */
+  public ArrayList<VerletSpring2D> springs;
+
+  /**
+   * Default time step = 1.0
+   */
+  protected float timeStep;
+
+  /**
+   * Default iterations for verlet solver = 50
+   */
+  protected int numIterations;
+
+  /**
+   * Optional bounding rect to constrain particles too
+   */
+  protected Rect worldBounds;
+
+  /**
+   *
+   */
+  public final List<ParticleBehavior2D> behaviors = new ArrayList<>(
+    1);
+
+  /**
+   *
+   */
+  public final List<ParticleConstraint2D> constraints = new ArrayList<>(
+    1);
+
+  /**
+   *
+   */
+  protected float drag;
+
+  /**
+   *
+   */
+  protected SpatialIndex<Vec2D> index;
+
+  /**
+   * Initializes a Verlet engine instance using the default values.
+   */
+  public VerletPhysics2D() {
+    this(null, 50, 0, 1);
+  }
+
+  /**
+   * Initializes an Verlet engine instance with the passed in configuration.
+   *
+   * @param gravity 3D gravity vector
+   * @param numIterations iterations per time step for verlet solver
+   * @param drag drag value 0...1
+   * @param timeStep time step for calculating forces
+   */
+  public VerletPhysics2D(Vec2D gravity, int numIterations, float drag,
+    float timeStep) {
+    particles = new ArrayList<>();
+    springs = new ArrayList<>();
+    this.numIterations = numIterations;
+    this.timeStep = timeStep;
+    setDrag(drag);
+    if (gravity != null) {
+      addBehavior(new GravityBehavior2D(gravity));
+    }
+  }
+
+  /**
+   *
+   * @param behavior
+   */
+  public final void addBehavior(ParticleBehavior2D behavior) {
+    behavior.configure(timeStep);
+    behaviors.add(behavior);
+  }
+
+  /**
+   *
+   * @param constraint
+   */
+  public void addConstraint(ParticleConstraint2D constraint) {
+    constraints.add(constraint);
+  }
+
+  /**
+   * Adds a particle to the list
+   *
+   * @param p
+   * @return itself
+   */
+  public VerletPhysics2D addParticle(VerletParticle2D p) {
+    particles.add(p);
+    return this;
+  }
+
+  /**
+   * Adds a spring connector
+   *
+   * @param s
+   * @return itself
+   */
+  public VerletPhysics2D addSpring(VerletSpring2D s) {
+    if (getSpring(s.a, s.b) == null) {
+      springs.add(s);
+    }
+    return this;
+  }
+
+  /**
+   * Applies all global constraints and constrains all particle positions to the
+   * world bounding rect set.
+   */
+  protected void applyConstaints() {
+    boolean hasGlobalConstraints = constraints.size() > 0;
+    particles.stream().map((p) -> {
+      if (hasGlobalConstraints) {
+        constraints.forEach((c) -> {
+          c.apply(p);
+        });
+      }
+      return p;
+    }).map((p) -> {
+      if (p.bounds != null) {
+        p.constrain(p.bounds);
+      }
+      return p;
+    }).filter((p) -> (worldBounds != null)).forEachOrdered((p) -> {
+      p.constrain(worldBounds);
+    });
+  }
+
+  /**
+   *
+   * @return
+   */
+  public VerletPhysics2D clear() {
+    behaviors.clear();
+    constraints.clear();
+    particles.clear();
+    springs.clear();
+    return this;
+  }
+
+  /**
+   *
+   * @return
+   */
+  public Rect getCurrentBounds() {
+    Vec2D min = new Vec2D(Float.MAX_VALUE, Float.MAX_VALUE);
+    Vec2D max = new Vec2D(Float.MIN_VALUE, Float.MIN_VALUE);
+    particles.stream().map((p) -> {
+      min.minSelf(p);
+      return p;
+    }).forEachOrdered((p) -> {
+      max.maxSelf(p);
+    });
+    return new Rect(min, max);
+  }
+
+  /**
+   *
+   * @return
+   */
+  public float getDrag() {
+    return 1f - drag;
+  }
+
+  /**
+   * @return the index
+   */
+  public SpatialIndex<Vec2D> getIndex() {
+    return index;
+  }
+
+  /**
+   * @return the numIterations
+   */
+  public int getNumIterations() {
+    return numIterations;
+  }
+
+  /**
+   * Attempts to find the spring element between the 2 particles supplied
+   *
+   * @param a particle 1
+   * @param b particle 2
+   * @return spring instance, or null if not found
+   */
+  public VerletSpring2D getSpring(Vec2D a, Vec2D b) {
+    for (VerletSpring2D s : springs) {
+      if ((s.a == a && s.b == b) || (s.a == b && s.b == a)) {
+        return s;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * @return the timeStep
+   */
+  public float getTimeStep() {
+    return timeStep;
+  }
+
+  /**
+   * @return the worldBounds
+   */
+  public Rect getWorldBounds() {
+    return worldBounds;
+  }
+
+  /**
+   *
+   * @param c
+   * @return
+   */
+  public boolean removeBehavior(ParticleBehavior2D c) {
+    return behaviors.remove(c);
+  }
+
+  /**
+   *
+   * @param c
+   * @return
+   */
+  public boolean removeConstraint(ParticleConstraint2D c) {
+    return constraints.remove(c);
+  }
+
+  /**
+   * Removes a particle from the simulation.
+   *
+   * @param p particle to remove
+   * @return true, if removed successfully
+   */
+  public boolean removeParticle(VerletParticle2D p) {
+    return particles.remove(p);
+  }
+
+  /**
+   * Removes a spring connector from the simulation instance.
+   *
+   * @param s spring to remove
+   * @return true, if the spring has been removed
+   */
+  public boolean removeSpring(VerletSpring2D s) {
+    return springs.remove(s);
+  }
+
+  /**
+   * Removes a spring connector and its both end point particles from the
+   * simulation
+   *
+   * @param s spring to remove
+   * @return true, only if spring AND particles have been removed successfully
+   */
+  public boolean removeSpringElements(VerletSpring2D s) {
+    if (removeSpring(s)) {
+      return (removeParticle(s.a) && removeParticle(s.b));
+    }
+    return false;
+  }
+
+  /**
+   *
+   * @param drag
+   */
+  public final void setDrag(float drag) {
+    this.drag = 1f - drag;
+  }
+
+  /**
+   * @param index the index to set
+   */
+  public void setIndex(SpatialIndex<Vec2D> index) {
+    this.index = index;
+  }
+
+  /**
+   * @param numIterations the numIterations to set
+   */
+  public void setNumIterations(int numIterations) {
+    this.numIterations = numIterations;
+  }
+
+  /**
+   * @param timeStep the timeStep to set
+   */
+  public void setTimeStep(float timeStep) {
+    this.timeStep = timeStep;
+    behaviors.forEach((b) -> {
+      b.configure(timeStep);
+    });
+  }
+
+  /**
+   * Sets bounding box
+   *
+   * @param world
+   * @return itself
+   */
+  public VerletPhysics2D setWorldBounds(Rect world) {
+    worldBounds = world;
+    return this;
+  }
+
+  /**
+   * Progresses the physics simulation by 1 time step and updates all forces and
+   * particle positions accordingly
+   *
+   * @return itself
+   */
+  public VerletPhysics2D update() {
+    updateParticles();
+    updateSprings();
+    applyConstaints();
+    updateIndex();
+    return this;
+  }
+
+  private void updateIndex() {
+    if (index != null) {
+      index.clear();
+      particles.forEach((p) -> {
+        index.index(p);
+      });
+    }
+  }
+
+  /**
+   * Updates all particle positions
+   */
+  protected void updateParticles() {
+    behaviors.forEach((b) -> {
+      if (index != null && b.supportsSpatialIndex()) {
+        b.applyWithIndex(index);
+      } else {
+        particles.forEach((p) -> {
+          b.apply(p);
+        });
+      }
+    });
+    particles.stream().map((p) -> {
+      p.scaleVelocity(drag);
+      return p;
+    }).forEachOrdered((p) -> {
+      p.update();
+    });
+  }
+
+  /**
+   * Updates all spring connections based on new particle positions
+   */
+  protected void updateSprings() {
+    if (springs.size() > 0) {
+      for (int i = numIterations; i > 0; i--) {
+        for (VerletSpring2D s : springs) {
+          s.update(i == 1);
+        }
+      }
+    }
+  }
+}

data/src/main/java/toxi/physics2d/behaviors/AttractionBehavior2D.java

@@ -0,0 +1,211 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * Copyright (c) 2006-2011 Karsten Schmidt
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ * 
+ * http://creativecommons.org/licenses/LGPL/2.1/
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+package toxi.physics2d.behaviors;
+
+import java.util.List;
+
+import toxi.geom.SpatialIndex;
+import toxi.geom.Vec2D;
+import toxi.physics2d.VerletParticle2D;
+
+/**
+ *
+ * @author tux
+ */
+public class AttractionBehavior2D implements ParticleBehavior2D {
+
+  /**
+   *
+   */
+  protected Vec2D attractor;
+
+  /**
+   *
+   */
+  protected float attrStrength;
+
+  protected float radius,
+    /**
+     *
+     */
+    /**
+     *
+     */
+    radiusSquared;
+
+  /**
+   *
+   */
+  protected float strength;
+
+  /**
+   *
+   */
+  protected float jitter;
+
+  /**
+   *
+   */
+  protected float timeStep;
+
+  /**
+   *
+   * @param attractor
+   * @param radius
+   * @param strength
+   */
+  public AttractionBehavior2D(Vec2D attractor, float radius, float strength) {
+    this(attractor, radius, strength, 0);
+  }
+
+  /**
+   *
+   * @param attractor
+   * @param radius
+   * @param strength
+   * @param jitter
+   */
+  public AttractionBehavior2D(Vec2D attractor, float radius, float strength,
+    float jitter) {
+    this.attractor = attractor;
+    this.strength = strength;
+    this.jitter = jitter;
+    setRadius(radius);
+  }
+
+  @Override
+  public void apply(VerletParticle2D p) {
+    Vec2D delta = attractor.sub(p);
+    float dist = delta.magSquared();
+    if (dist < radiusSquared) {
+      Vec2D f = delta.normalizeTo((1.0f - dist / radiusSquared))
+        .jitter(jitter).scaleSelf(attrStrength);
+      p.addForce(f);
+    }
+  }
+
+  /**
+   *
+   * @param spaceHash
+   */
+  @Override
+  public void applyWithIndex(SpatialIndex<Vec2D> spaceHash) {
+    List<Vec2D> selection = spaceHash.itemsWithinRadius(attractor, radius,
+      null);
+    final Vec2D temp = new Vec2D();
+    if (selection != null) {
+      selection.stream().map((p) -> {
+        temp.set(p);
+        return p;
+      }).map((p) -> {
+        apply((VerletParticle2D) p);
+        return p;
+      }).forEachOrdered((p) -> {
+        spaceHash.reindex(temp, p);
+      });
+    }
+  }
+
+  /**
+   *
+   * @param timeStep
+   */
+  @Override
+  public void configure(float timeStep) {
+    this.timeStep = timeStep;
+    setStrength(strength);
+  }
+
+  /**
+   * @return the attractor
+   */
+  public Vec2D getAttractor() {
+    return attractor;
+  }
+
+  /**
+   * @return the jitter
+   */
+  public float getJitter() {
+    return jitter;
+  }
+
+  /**
+   * @return the radius
+   */
+  public float getRadius() {
+    return radius;
+  }
+
+  /**
+   * @return the strength
+   */
+  public float getStrength() {
+    return strength;
+  }
+
+  /**
+   * @param attractor the attractor to set
+   */
+  public void setAttractor(Vec2D attractor) {
+    this.attractor = attractor;
+  }
+
+  /**
+   * @param jitter the jitter to set
+   */
+  public void setJitter(float jitter) {
+    this.jitter = jitter;
+  }
+
+  /**
+   *
+   * @param r
+   */
+  public final void setRadius(float r) {
+    this.radius = r;
+    this.radiusSquared = r * r;
+  }
+
+  /**
+   * @param strength the strength to set
+   */
+  public void setStrength(float strength) {
+    this.strength = strength;
+    this.attrStrength = strength * timeStep;
+  }
+
+  /**
+   *
+   * @return
+   */
+  @Override
+  public boolean supportsSpatialIndex() {
+    return true;
+  }
+
+}

data/src/{toxi → main/java/toxi}/physics3d/ParticlePath3D.java

@@ -78,11 +78,12 @@ public class ParticlePath3D extends Spline3D {
     public List<VerletParticle3D> createParticles(VerletPhysics3D physics,
             int subDiv, float step, float mass) {
         particles.clear();
-        for (Vec3D v : toLineStrip3D(subDiv).getDecimatedVertices(step, true)) {
-            VerletParticle3D p = createSingleParticle(v, mass);
+        toLineStrip3D(subDiv).getDecimatedVertices(step, true).stream().map((v) -> createSingleParticle(v, mass)).map((p) -> {
             particles.add(p);
+            return p;
+        }).forEachOrdered((p) -> {
             physics.addParticle(p);
-        }
+        });
         return particles;
     }
 

data/src/{toxi → main/java/toxi}/physics3d/ParticleString3D.java

@@ -129,9 +129,9 @@ public class ParticleString3D {
      * particles & springs.
      */
     public void clear() {
-        for (VerletSpring3D s : links) {
+        links.forEach((s) -> {
             physics.removeSpringElements(s);
-        }
+        });
         particles.clear();
         links.clear();
     }