toxiclibs 0.9.2 → 2.1.0

data/src/{toxi → main/java/toxi}/newmesh/IndexedTriangleMesh.java

@@ -156,7 +156,7 @@ public class IndexedTriangleMesh {
             HashMap<String, Object[]> attribs) {
         HashMap<String, int[]> fattribs = null;
         if (attribs != null) {
-            fattribs = (f != null) ? f.attribs : new HashMap<String, int[]>(
+            fattribs = (f != null) ? f.attribs : new HashMap<>(
                     attribs.size(), 1);
             for (String attID : attribs.keySet()) {
                 Object[] items = attribs.get(attID);
@@ -197,9 +197,9 @@ public class IndexedTriangleMesh {
         Vec3D[] v = null;
         for (AttributedFace f : mesh.faces) {
             attribs.clear();
-            for (String a : f.attribs.keySet()) {
-                attribs.put(a, mesh.getFaceAttribValues(f, a));
-            }
+            f.attribs.keySet().forEach((a) -> {
+              attribs.put(a, mesh.getFaceAttribValues(f, a));
+          });
             v = mesh.getFaceVertices(f, v);
             addFace(v[0], v[1], v[2], attribs);
         }
@@ -244,21 +244,21 @@ public class IndexedTriangleMesh {
         }
         HashMap<String, float[]> buffers = new HashMap<>();
         int numF = faces.size();
-        for (String attrib : attribs) {
-            MeshAttributeCompiler comp = mergedComps.get(attrib);
-            if (comp != null) {
-                comp.setMesh(this);
-                ItemIndex<?> index = comp.getIndex();
-                int faceStride = 3 * comp.getStride();
-                float[] buf = new float[numF * faceStride];
-                int offset = 0;
-                for (AttributedFace f : faces) {
-                    comp.compileFace(f, index, buf, offset);
-                    offset += faceStride;
-                }
-                buffers.put(attrib, buf);
-            }
-        }
+        attribs.forEach((attrib) -> {
+          MeshAttributeCompiler comp = mergedComps.get(attrib);
+        if (comp != null) {
+          comp.setMesh(this);
+          ItemIndex<?> index = comp.getIndex();
+          int faceStride = 3 * comp.getStride();
+          float[] buf = new float[numF * faceStride];
+          int offset = 0;
+          for (AttributedFace f : faces) {
+            comp.compileFace(f, index, buf, offset);
+            offset += faceStride;
+          }
+          buffers.put(attrib, buf);
+        }
+      });
         return buffers;
     }
 
@@ -269,15 +269,17 @@ public class IndexedTriangleMesh {
     public List<Object> computeEdges() {
         ItemIndex<Object> edges = getAttributeIndex(ATTR_EDGES);
         edges.clear();
-        for (AttributedFace f : faces) {
-            if (f.attribs == null) {
-                f.attribs = new HashMap<>();
-            }
-            f.attribs.put(ATTR_EDGES, new int[] {
-                    indexFaceEdge(f, f.a, f.b), indexFaceEdge(f, f.b, f.c),
-                    indexFaceEdge(f, f.c, f.a)
-            });
-        }
+        faces.stream().map((f) -> {
+          if (f.attribs == null) {
+            f.attribs = new HashMap<>();
+          }
+        return f;
+      }).forEachOrdered((f) -> {
+        f.attribs.put(ATTR_EDGES, new int[] {
+          indexFaceEdge(f, f.a, f.b), indexFaceEdge(f, f.b, f.c),
+          indexFaceEdge(f, f.c, f.a)
+        });
+      });
         return edges.getItems();
     }
 
@@ -305,28 +307,30 @@ public class IndexedTriangleMesh {
         for (int i = 0; i < vnorms.length; i++) {
             vnorms[i] = new Vec3D();
         }
-        for (AttributedFace f : faces) {
-            final Vec3D n = fnormals.forID(f.normal);
-            vnorms[f.a].addSelf(n);
-            vnorms[f.b].addSelf(n);
-            vnorms[f.c].addSelf(n);
-        }
+        faces.forEach((f) -> {
+          final Vec3D n = fnormals.forID(f.normal);
+          vnorms[f.a].addSelf(n);
+          vnorms[f.b].addSelf(n);
+          vnorms[f.c].addSelf(n);
+      });
         for (Vec3D vnorm : vnorms) {
             vnorm.normalize();
         }
         ItemIndex<Object> idx = getAttributeIndex(ATTR_VNORMALS);
         idx.clear();
-        for (AttributedFace f : faces) {
-            if (f.attribs == null) {
-                f.attribs = new HashMap<>();
-            }
-            f.attribs.put(
-                    ATTR_VNORMALS,
-                    new int[] {
-                            idx.index(vnorms[f.a]), idx.index(vnorms[f.b]),
-                            idx.index(vnorms[f.c])
-                    });
-        }
+        faces.stream().map((f) -> {
+          if (f.attribs == null) {
+            f.attribs = new HashMap<>();
+          }
+        return f;
+      }).forEachOrdered((f) -> {
+        f.attribs.put(
+          ATTR_VNORMALS,
+          new int[] {
+            idx.index(vnorms[f.a]), idx.index(vnorms[f.b]),
+            idx.index(vnorms[f.c])
+          });
+      });
         return idx.getItems();
     }
 
@@ -366,26 +370,26 @@ public class IndexedTriangleMesh {
      * @return itself
      */
     public IndexedTriangleMesh flipVertexOrder() {
-        for (AttributedFace f : faces) {
-            int t = f.b;
-            f.b = f.c;
-            f.c = t;
-            if (f.attribs != null) {
-                for (int[] att : f.attribs.values()) {
-                    t = att[1];
-                    att[1] = att[2];
-                    att[2] = t;
-                }
-            }
-        }
-        for (Vec3D n : fnormals.getItems()) {
-            fnormals.reindex(n, n.getInverted());
-        }
+      faces.forEach((f) -> {
+        int t = f.b;
+        f.b = f.c;
+        f.c = t;
+        if (f.attribs != null) {
+          for (int[] att : f.attribs.values()) {
+            t = att[1];
+            att[1] = att[2];
+            att[2] = t;
+          }
+        }
+      });
+      fnormals.getItems().forEach((n) -> {
+        fnormals.reindex(n, n.getInverted());
+      });
         ItemIndex<Object> vnormals = attributes.get(ATTR_VNORMALS);
         if (vnormals != null) {
-            for (Object n : vnormals.getItems()) {
-                vnormals.reindex(n, ((Vec3D) n).getInverted());
-            }
+          vnormals.getItems().forEach((n) -> {
+            vnormals.reindex(n, ((Vec3D) n).getInverted());
+        });
         }
         return this;
     }
@@ -488,12 +492,9 @@ public class IndexedTriangleMesh {
      */
     public List<AttributedEdge> getEdgesForVertexID(int id) {
         List<AttributedEdge> vedges = new ArrayList<>(2);
-        for (Object o : getEdges()) {
-            AttributedEdge e = (AttributedEdge) o;
-            if (e.a == id || e.b == id) {
-                vedges.add(e);
-            }
-        }
+        getEdges().stream().map((o) -> (AttributedEdge) o).filter((e) -> (e.a == id || e.b == id)).forEachOrdered((e) -> {
+          vedges.add(e);
+      });
         return vedges;
     }
 

data/src/{toxi → main/java/toxi}/physics2d/ParticlePath2D.java

@@ -78,11 +78,12 @@ public class ParticlePath2D extends Spline2D {
     public List<VerletParticle2D> createParticles(VerletPhysics2D physics,
             int subDiv, float step, float mass) {
         particles.clear();
-        for (Vec2D v : toLineStrip2D(subDiv).getDecimatedVertices(step, true)) {
-            VerletParticle2D p = createSingleParticle(v, mass);
+        toLineStrip2D(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}/physics2d/ParticleString2D.java

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

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

@@ -0,0 +1,449 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * 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.Collection;
+import java.util.List;
+
+import toxi.geom.ReadonlyVec2D;
+import toxi.geom.Rect;
+import toxi.geom.Vec2D;
+import toxi.physics2d.behaviors.ParticleBehavior2D;
+import toxi.physics2d.constraints.ParticleConstraint2D;
+
+/**
+ * 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 VerletParticle2D extends Vec2D {
+
+  protected Vec2D prev,
+    /**
+     *
+     */
+    /**
+     *
+     */
+    temp;
+
+  /**
+   *
+   */
+  protected boolean isLocked;
+
+  /**
+   * Bounding box, by default set to null to disable
+   */
+  public Rect bounds;
+
+  /**
+   * An optional particle constraints, called immediately after a particle is
+   * updated (and only used if particle is unlocked (default)
+   */
+  public List<ParticleConstraint2D> constraints;
+
+  /**
+   *
+   */
+  public List<ParticleBehavior2D> behaviors;
+  /**
+   * Particle weight, default = 1
+   */
+  protected float weight, invWeight;
+
+  /**
+   *
+   */
+  protected Vec2D force = new Vec2D();
+
+  /**
+   * Creates particle at position xyz
+   *
+   * @param x
+   * @param y
+   */
+  public VerletParticle2D(float x, float y) {
+    this(x, y, 1);
+  }
+
+  /**
+   * Creates particle at position xyz with weight w
+   *
+   * @param x
+   * @param y
+   * @param w
+   */
+  public VerletParticle2D(float x, float y, float w) {
+    super(x, y);
+    prev = new Vec2D(this);
+    temp = new Vec2D();
+    setWeight(w);
+  }
+
+  /**
+   * Creates particle at the position of the passed in vector
+   *
+   * @param v position
+   */
+  public VerletParticle2D(ReadonlyVec2D v) {
+    this(v.x(), v.y(), 1);
+  }
+
+  /**
+   * Creates particle with weight w at the position of the passed in vector
+   *
+   * @param v position
+   * @param w weight
+   */
+  public VerletParticle2D(ReadonlyVec2D v, float w) {
+    this(v.x(), v.y(), w);
+  }
+
+  /**
+   * Creates a copy of the passed in particle
+   *
+   * @param p
+   */
+  public VerletParticle2D(VerletParticle2D p) {
+    this(p.x, p.y, p.weight);
+    isLocked = p.isLocked;
+  }
+
+  /**
+   *
+   * @param behavior
+   * @return
+   */
+  public VerletParticle2D addBehavior(ParticleBehavior2D behavior) {
+    return addBehavior(behavior, 1);
+  }
+
+  /**
+   *
+   * @param behavior
+   * @param timeStep
+   * @return
+   */
+  public VerletParticle2D addBehavior(ParticleBehavior2D behavior,
+    float timeStep) {
+    if (behaviors == null) {
+      behaviors = new ArrayList<>(1);
+    }
+    behavior.configure(timeStep);
+    behaviors.add(behavior);
+    return this;
+  }
+
+  /**
+   *
+   * @param behaviors
+   * @return
+   */
+  public VerletParticle2D addBehaviors(
+    Collection<ParticleBehavior2D> behaviors) {
+    return addBehaviors(behaviors, 1);
+  }
+
+  /**
+   *
+   * @param behaviors
+   * @param timeStemp
+   * @return
+   */
+  public VerletParticle2D addBehaviors(
+    Collection<ParticleBehavior2D> behaviors, float timeStemp) {
+    behaviors.forEach((b) -> {
+      addBehavior(b, timeStemp);
+    });
+    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 VerletParticle2D addConstraint(ParticleConstraint2D c) {
+    if (constraints == null) {
+      constraints = new ArrayList<>(1);
+    }
+    constraints.add(c);
+    return this;
+  }
+
+  /**
+   *
+   * @param constraints
+   * @return
+   */
+  public VerletParticle2D addConstraints(
+    Collection<ParticleConstraint2D> constraints) {
+    constraints.forEach((c) -> {
+      addConstraint(c);
+    });
+    return this;
+  }
+
+  /**
+   *
+   * @param f
+   * @return
+   */
+  public VerletParticle2D addForce(Vec2D f) {
+    force.addSelf(f);
+    return this;
+  }
+
+  /**
+   *
+   * @param v
+   * @return
+   */
+  public VerletParticle2D addVelocity(Vec2D 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();
+  }
+
+  /**
+   *
+   * @return
+   */
+  public VerletParticle2D clearForce() {
+    force.clear();
+    return this;
+  }
+
+  /**
+   *
+   * @return
+   */
+  public VerletParticle2D clearVelocity() {
+    prev.set(this);
+    return this;
+  }
+
+  /**
+   *
+   * @return
+   */
+  public Vec2D getForce() {
+    return force;
+  }
+
+  /**
+   * @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 Vec2D getPreviousPosition() {
+    return prev;
+  }
+
+  /**
+   *
+   * @return
+   */
+  public Vec2D 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 VerletParticle2D lock() {
+    isLocked = true;
+    return this;
+  }
+
+  /**
+   *
+   * @return
+   */
+  public VerletParticle2D removeAllBehaviors() {
+    behaviors.clear();
+    return this;
+  }
+
+  /**
+   * Removes any currently applied constraints from this particle.
+   *
+   * @return itself
+   */
+  public VerletParticle2D removeAllConstraints() {
+    constraints.clear();
+    return this;
+  }
+
+  /**
+   *
+   * @param b
+   * @return
+   */
+  public boolean removeBehavior(ParticleBehavior2D b) {
+    return behaviors.remove(b);
+  }
+
+  /**
+   *
+   * @param behaviors
+   * @return
+   */
+  public boolean removeBehaviors(Collection<ParticleBehavior2D> behaviors) {
+    return this.behaviors.removeAll(behaviors);
+  }
+
+  /**
+   * 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(ParticleConstraint2D c) {
+    return constraints.remove(c);
+  }
+
+  /**
+   *
+   * @param constraints
+   * @return
+   */
+  public boolean removeConstraints(
+    Collection<ParticleConstraint2D> constraints) {
+    return this.constraints.removeAll(constraints);
+  }
+
+  /**
+   *
+   * @param scl
+   * @return
+   */
+  public VerletParticle2D scaleVelocity(float scl) {
+    prev.interpolateToSelf(this, 1f - scl);
+    return this;
+  }
+
+  /**
+   *
+   * @param p
+   * @return
+   */
+  public VerletParticle2D setPreviousPosition(Vec2D p) {
+    prev.set(p);
+    return this;
+  }
+
+  /**
+   *
+   * @param w
+   */
+  public final void setWeight(float w) {
+    weight = w;
+    invWeight = 1f / w;
+  }
+
+  /**
+   * Unlocks particle again
+   *
+   * @return itself
+   */
+  public VerletParticle2D unlock() {
+    clearVelocity();
+    isLocked = false;
+    return this;
+  }
+
+  /**
+   *
+   */
+  public void update() {
+    if (!isLocked) {
+      applyBehaviors();
+      applyForce();
+      applyConstraints();
+    }
+  }
+}