toxiclibs 0.9.2 → 2.1.0

data/src/main/java/toxi/physics3d/VerletParticle3D.java

@@ -0,0 +1,377 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * 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.physics3d;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import toxi.geom.AABB;
+import toxi.geom.ReadonlyVec3D;
+import toxi.geom.Vec3D;
+import toxi.physics3d.behaviors.ParticleBehavior3D;
+import toxi.physics3d.constraints.ParticleConstraint3D;
+
+/**
+ * An individual 3D particle for use by the VerletPhysics and VerletSpring
+ * classes. A particle has weight, can be locked in space and its position
+ * constrained inside an (optional) axis-aligned bounding box.
+ */
+public class VerletParticle3D extends Vec3D {
+
+  protected Vec3D prev,
+    /**
+     *
+     */
+    /**
+     *
+     */
+    temp;
+
+  /**
+   *
+   */
+  protected boolean isLocked;
+
+  /**
+   * Bounding box, by default set to null to disable
+   */
+  public AABB bounds;
+
+  /**
+   * An optional particle constraints, called immediately after a particle is
+   * updated (and only used if particle is unlocked (default)
+   */
+  public List<ParticleConstraint3D> constraints;
+
+  /**
+   *
+   */
+  public List<ParticleBehavior3D> behaviors;
+
+  /**
+   * Particle weight, default = 1
+   */
+  protected float weight, invWeight;
+
+  /**
+   *
+   */
+  protected Vec3D force = new Vec3D();
+
+  /**
+   * Creates particle at position xyz
+   *
+   * @param x
+   * @param y
+   * @param z
+   */
+  public VerletParticle3D(float x, float y, float z) {
+    this(x, y, z, 1);
+  }
+
+  /**
+   * Creates particle at position xyz with weight w
+   *
+   * @param x
+   * @param y
+   * @param z
+   * @param w
+   */
+  public VerletParticle3D(float x, float y, float z, float w) {
+    super(x, y, z);
+    prev = new Vec3D(this);
+    temp = new Vec3D();
+    setWeight(w);
+  }
+
+  /**
+   * Creates particle at the position of the passed in vector
+   *
+   * @param v position
+   */
+  public VerletParticle3D(ReadonlyVec3D v) {
+    this(v.x(), v.y(), v.z(), 1);
+  }
+
+  /**
+   * Creates particle with weight w at the position of the passed in vector
+   *
+   * @param v position
+   * @param w weight
+   */
+  public VerletParticle3D(ReadonlyVec3D v, float w) {
+    this(v.x(), v.y(), v.z(), w);
+  }
+
+  /**
+   * Creates a copy of the passed in particle
+   *
+   * @param p
+   */
+  public VerletParticle3D(VerletParticle3D p) {
+    this(p.x, p.y, p.z, p.weight);
+    isLocked = p.isLocked;
+  }
+
+  /**
+   *
+   * @param behavior
+   * @return
+   */
+  public VerletParticle3D addBehavior(ParticleBehavior3D behavior) {
+    return addBehavior(behavior, 1);
+  }
+
+  /**
+   *
+   * @param behavior
+   * @param timeStep
+   * @return
+   */
+  public VerletParticle3D addBehavior(ParticleBehavior3D behavior, float timeStep) {
+    if (behaviors == null) {
+      behaviors = new ArrayList<>(1);
+    }
+    behavior.configure(timeStep);
+    behaviors.add(behavior);
+    return this;
+  }
+
+  /**
+   * Adds the given constraint implementation to the list of constraints applied
+   * to this particle at each time step.
+   *
+   * @param c constraint instance
+   * @return itself
+   */
+  public VerletParticle3D addConstraint(ParticleConstraint3D c) {
+    if (constraints == null) {
+      constraints = new ArrayList<>(1);
+    }
+    constraints.add(c);
+    return this;
+  }
+
+  /**
+   *
+   * @param f
+   * @return
+   */
+  public VerletParticle3D addForce(Vec3D f) {
+    force.addSelf(f);
+    return this;
+  }
+
+  /**
+   *
+   * @param v
+   * @return
+   */
+  public VerletParticle3D addVelocity(Vec3D v) {
+    prev.subSelf(v);
+    return this;
+  }
+
+  /**
+   *
+   */
+  public void applyBehaviors() {
+    if (behaviors != null) {
+      behaviors.forEach((b) -> {
+        b.apply(this);
+      });
+    }
+  }
+
+  /**
+   *
+   */
+  public void applyConstraints() {
+    if (constraints != null) {
+      constraints.forEach((pc) -> {
+        pc.apply(this);
+      });
+    }
+  }
+
+  /**
+   *
+   */
+  protected void applyForce() {
+    temp.set(this);
+    addSelf(sub(prev).addSelf(force.scale(weight)));
+    prev.set(temp);
+    force.clear();
+  }
+
+  /**
+   * Removes any currently applied constraints from this particle.
+   *
+   * @return itself
+   */
+  public VerletParticle3D clearConstraints() {
+    constraints.clear();
+    return this;
+  }
+
+  /**
+   *
+   * @return
+   */
+  public VerletParticle3D clearForce() {
+    force.clear();
+    return this;
+  }
+
+  /**
+   *
+   * @return
+   */
+  public VerletParticle3D clearVelocity() {
+    prev.set(this);
+    return this;
+  }
+
+  /**
+   * @return the inverse weight (1/weight)
+   */
+  public final float getInvWeight() {
+    return invWeight;
+  }
+
+  /**
+   * Returns the particle's position at the most recent time step.
+   *
+   * @return previous position
+   */
+  public Vec3D getPreviousPosition() {
+    return prev;
+  }
+
+  /**
+   *
+   * @return
+   */
+  public Vec3D getVelocity() {
+    return sub(prev);
+  }
+
+  /**
+   * @return the weight
+   */
+  public final float getWeight() {
+    return weight;
+  }
+
+  /**
+   * @return true, if particle is locked
+   */
+  public final boolean isLocked() {
+    return isLocked;
+  }
+
+  /**
+   * Locks/immobilizes particle in space
+   *
+   * @return itself
+   */
+  public VerletParticle3D lock() {
+    isLocked = true;
+    return this;
+  }
+
+  /**
+   *
+   * @param b
+   * @return
+   */
+  public boolean removeBehavior(ParticleBehavior3D b) {
+    return behaviors.remove(b);
+  }
+
+  /**
+   * Attempts to remove the given constraint instance from the list of active
+   * constraints.
+   *
+   * @param c constraint to remove
+   * @return true, if successfully removed
+   */
+  public boolean removeConstraint(ParticleConstraint3D c) {
+    return constraints.remove(c);
+  }
+
+  /**
+   *
+   * @param scl
+   * @return
+   */
+  public VerletParticle3D scaleVelocity(float scl) {
+    prev.interpolateToSelf(this, 1f - scl);
+    return this;
+  }
+
+  /**
+   *
+   * @param p
+   * @return
+   */
+  public VerletParticle3D setPreviousPosition(Vec3D p) {
+    prev.set(p);
+    return this;
+  }
+
+  /**
+   *
+   * @param w
+   */
+  public void setWeight(float w) {
+    weight = w;
+    invWeight = 1f / w;
+  }
+
+  /**
+   * Unlocks particle again
+   *
+   * @return itself
+   */
+  public VerletParticle3D unlock() {
+    clearVelocity();
+    isLocked = false;
+    return this;
+  }
+
+  /**
+   *
+   */
+  public void update() {
+    if (!isLocked) {
+      applyBehaviors();
+      applyForce();
+      applyConstraints();
+    }
+  }
+}

data/src/{toxi → main/java/toxi}/physics3d/constraints/AxisConstraint.java

@@ -61,6 +61,7 @@ public class AxisConstraint implements ParticleConstraint3D {
      * 
      * @see toxi.physics.IParticleConstraint#apply(toxi.physics.VerletParticle)
      */
+    @Override
     public void apply(VerletParticle3D p) {
         p.setComponent(axis, constraint);
     }

data/src/{toxi → main/java/toxi}/physics3d/constraints/CylinderConstraint.java

@@ -60,6 +60,7 @@ public class CylinderConstraint implements ParticleConstraint3D {
         setCylinder(cylinder);
     }
 
+    @Override
     public void apply(VerletParticle3D p) {
         if (cylinder.containsPoint(p)) {
             centroid.setComponent(axis, p.getComponent(axis));

data/src/{toxi → main/java/toxi}/physics3d/constraints/MaxConstraint.java

@@ -56,6 +56,7 @@ public class MaxConstraint implements ParticleConstraint3D {
         this.threshold = threshold;
     }
 
+    @Override
     public void apply(VerletParticle3D p) {
         if (p.getComponent(axis) > threshold) {
             p.setComponent(axis, threshold);

data/src/{toxi → main/java/toxi}/physics3d/constraints/MinConstraint.java

@@ -56,6 +56,7 @@ public class MinConstraint implements ParticleConstraint3D {
         this.threshold = threshold;
     }
 
+    @Override
     public void apply(VerletParticle3D p) {
         if (p.getComponent(axis) < threshold) {
             p.setComponent(axis, threshold);

data/src/{toxi → main/java/toxi}/physics3d/constraints/SoftBoxConstraint.java

@@ -24,7 +24,6 @@
  * 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.physics3d.constraints;
 
 import java.util.LinkedList;
@@ -40,48 +39,49 @@ import toxi.physics3d.VerletParticle3D;
  */
 public class SoftBoxConstraint implements ParticleConstraint3D {
 
-    /**
-     *
-     */
-    public AABB box;
+  /**
+   *
+   */
+  public AABB box;
 
-    /**
-     *
-     */
-    public List<Axis> axes = new LinkedList<Axis>();
+  /**
+   *
+   */
+  public List<Axis> axes = new LinkedList<>();
 
-    /**
-     *
-     */
-    public float smooth;
+  /**
+   *
+   */
+  public float smooth;
 
-    /**
-     *
-     * @param box
-     * @param smooth
-     */
-    public SoftBoxConstraint(AABB box, float smooth) {
-        this.box = box;
-        this.smooth = smooth;
-    }
+  /**
+   *
+   * @param box
+   * @param smooth
+   */
+  public SoftBoxConstraint(AABB box, float smooth) {
+    this.box = box;
+    this.smooth = smooth;
+  }
 
-    /**
-     *
-     * @param a
-     * @return
-     */
-    public SoftBoxConstraint addAxis(Axis a) {
-        axes.add(a);
-        return this;
-    }
+  /**
+   *
+   * @param a
+   * @return
+   */
+  public SoftBoxConstraint addAxis(Axis a) {
+    axes.add(a);
+    return this;
+  }
 
-    public void apply(VerletParticle3D p) {
-        if (p.isInAABB(box)) {
-            for (Axis a : axes) {
-                float val = p.getComponent(a);
-                p.setComponent(a, val + (box.getComponent(a) - val) * smooth);
-            }
-        }
+  @Override
+  public void apply(VerletParticle3D p) {
+    if (p.isInAABB(box)) {
+      axes.forEach((a) -> {
+        float val = p.getComponent(a);
+        p.setComponent(a, val + (box.getComponent(a) - val) * smooth);
+      });
     }
+  }
 
 }

data/src/{toxi → main/java/toxi}/physics3d/constraints/SphereConstraint.java

@@ -98,6 +98,7 @@ public class SphereConstraint implements ParticleConstraint3D {
      * toxi.physics.constraints.ParticleConstraint#apply(toxi.physics.VerletParticle
      * )
      */
+    @Override
     public void apply(VerletParticle3D p) {
         boolean isInside = sphere.containsPoint(p);
         if ((isBoundingSphere && !isInside) || (!isBoundingSphere && isInside)) {

data/src/{toxi → main/java/toxi}/processing/ToxiclibsSupport.java

@@ -73,7 +73,7 @@ public class ToxiclibsSupport {
     /**
      *
      */
-    protected static final Logger logger = Logger
+    protected static final Logger LOGGER = Logger
             .getLogger(ToxiclibsSupport.class.getName());
 
     /**
@@ -237,7 +237,7 @@ public class ToxiclibsSupport {
                 gfx.ellipse(e.x - r.x, e.y - r.y, r.x * 2, r.y * 2);
                 break;
             default:
-                logger.log(Level.WARNING, "invalid ellipse mode: {0}", gfx.ellipseMode);
+                LOGGER.log(Level.WARNING, "invalid ellipse mode: {0}", gfx.ellipseMode);
         }
     }
 
@@ -968,7 +968,7 @@ public class ToxiclibsSupport {
                 gfx.rect(r.x + rw, r.y + rh, rw, rh);
                 break;
             default:
-                logger.log(Level.WARNING, "invalid rect mode: {0}", gfx.rectMode);
+                LOGGER.log(Level.WARNING, "invalid rect mode: {0}", gfx.rectMode);
         }
     }