toxiclibs 0.2-java → 0.5.0-java

data/src/toxi/physics2d/constraints/RectConstraint.java

@@ -0,0 +1,114 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * 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.constraints;
+
+import toxi.geom.Ray2D;
+import toxi.geom.Rect;
+import toxi.geom.Vec2D;
+import toxi.physics2d.VerletParticle2D;
+
+/**
+ *
+ * @author tux
+ */
+public class RectConstraint implements ParticleConstraint2D {
+
+    /**
+     *
+     */
+    protected Rect rect;
+
+    /**
+     *
+     */
+    protected Ray2D intersectRay;
+
+    /**
+     *
+     */
+    protected boolean isContainer;
+
+    /**
+     *
+     * @param rect
+     */
+    public RectConstraint(Rect rect) {
+        this(rect, false);
+    }
+
+    /**
+     *
+     * @param rect
+     * @param isContainer
+     */
+    public RectConstraint(Rect rect, boolean isContainer) {
+        this.isContainer = isContainer;
+        setBox(rect);
+    }
+
+    /**
+     *
+     * @param min
+     * @param max
+     */
+    public RectConstraint(Vec2D min, Vec2D max) {
+        this(new Rect(min, max), false);
+    }
+
+    @Override
+    public void apply(VerletParticle2D p) {
+        if (isContainer) {
+            if (!rect.containsPoint(p)) {
+                p.constrain(rect);
+            }
+        } else {
+            if (rect.containsPoint(p)) {
+                p.set(rect.intersectsRay(
+                        intersectRay.setDirection(intersectRay.sub(p)), 0,
+                        Float.MAX_VALUE));
+            }
+        }
+    }
+
+    /**
+     *
+     * @return
+     */
+    public Rect getBox() {
+        return rect.copy();
+    }
+
+    /**
+     *
+     * @param rect
+     */
+    public final void setBox(Rect rect) {
+        this.rect = rect.copy();
+        this.intersectRay = new Ray2D(rect.getCentroid(), new Vec2D());
+    }
+}

data/src/toxi/physics3d/ParticlePath3D.java

@@ -0,0 +1,100 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * 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.Spline3D;
+import toxi.geom.Vec3D;
+
+/**
+ * This class is used as a builder to dynamically construct a
+ * {@link ParticleString3D} following a given spline path, sampled at a fixed
+ * frequency/step distance. This functionality is needed especially when working
+ * with various obstacles/mechanic constraints which the string should flow/wrap
+ * around.
+ */
+public class ParticlePath3D extends Spline3D {
+
+    List<VerletParticle3D> particles = new ArrayList<>();
+
+    /**
+     *
+     */
+    public ParticlePath3D() {
+        super();
+    }
+
+    /**
+     *
+     * @param points
+     */
+    public ParticlePath3D(List<Vec3D> points) {
+        super(points);
+    }
+
+    /**
+     * Creates particles along the spline at the fixed interval given. The
+     * precision of this interval will largely depend on the number of
+     * subdivision vertices created, but can be adjusted via the related
+     * parameter.
+     * 
+     * @param physics
+     *            physics instance
+     * @param subDiv
+     *            number spline segment subdivisions
+     * @param step
+     *            desired rest length between particles
+     * @param mass
+     *            desired particle mass
+     * @return list of particles
+     */
+    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);
+            particles.add(p);
+            physics.addParticle(p);
+        }
+        return particles;
+    }
+
+    /**
+     * Extension point for creating a custom/sub-classed VerletParticle
+     * instance.
+     * 
+     * @param pos
+     * @param mass
+     * @return particle
+     */
+    protected VerletParticle3D createSingleParticle(Vec3D pos, float mass) {
+        return new VerletParticle3D(pos, mass);
+    }
+}

data/src/toxi/physics3d/ParticleString3D.java

@@ -0,0 +1,184 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * 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.Vec3D;
+
+/**
+ * Utility builder/grouping/management class to connect a set of particles into
+ * a physical string/thread. Custom spring types can be used by subclassing this
+ * class and overwriting the
+ * {@link #createSpring(VerletParticle3D, VerletParticle3D, float, float)} method.
+ */
+public class ParticleString3D {
+
+    /**
+     *
+     */
+    protected VerletPhysics3D physics;
+
+    /**
+     *
+     */
+    public List<VerletParticle3D> particles;
+
+    /**
+     *
+     */
+    public List<VerletSpring3D> links;
+
+    /**
+     * Takes a list of already created particles connects them into a continuous
+     * string using springs.
+     * 
+     * @param physics
+     *            physics engine instance
+     * @param plist
+     *            particle list
+     * @param strength
+     *            spring strength
+     */
+    public ParticleString3D(VerletPhysics3D physics, List<VerletParticle3D> plist,
+            float strength) {
+        this.physics = physics;
+        particles = new ArrayList<>(plist);
+        links = new ArrayList<>(particles.size() - 1);
+        VerletParticle3D prev = null;
+        for (VerletParticle3D p : particles) {
+            physics.addParticle(p);
+            if (prev != null) {
+                VerletSpring3D s = createSpring(prev, p, prev.distanceTo(p),
+                        strength);
+                links.add(s);
+                physics.addSpring(s);
+            }
+            prev = p;
+
+        }
+    }
+
+    /**
+     * Creates a number of particles along a line and connects them into a
+     * string using springs.
+     * 
+     * @param physics
+     *            physics engine
+     * @param pos
+     *            start position
+     * @param step
+     *            step direction & distance between successive particles
+     * @param num
+     *            number of particles
+     * @param mass
+     *            particle mass
+     * @param strength
+     *            spring strength
+     */
+    public ParticleString3D(VerletPhysics3D physics, Vec3D pos, Vec3D step,
+            int num, float mass, float strength) {
+        this.physics = physics;
+        particles = new ArrayList<>(num);
+        links = new ArrayList<>(num - 1);
+        float len = step.magnitude();
+        VerletParticle3D prev = null;
+        pos = pos.copy();
+        for (int i = 0; i < num; i++) {
+            VerletParticle3D p = new VerletParticle3D(pos.copy(), mass);
+            particles.add(p);
+            physics.particles.add(p);
+            if (prev != null) {
+                VerletSpring3D s = createSpring(prev, p, len, strength);
+                links.add(s);
+                physics.addSpring(s);
+            }
+            prev = p;
+            pos.addSelf(step);
+        }
+    }
+
+    /**
+     * Removes the entire string from the physics simulation, incl. all of its
+     * particles & springs.
+     */
+    public void clear() {
+        for (VerletSpring3D s : links) {
+            physics.removeSpringElements(s);
+        }
+        particles.clear();
+        links.clear();
+    }
+
+    /**
+     * Creates a spring instance connecting 2 successive particles of the
+     * string. Overwrite this method to create a string custom spring types
+     * (subclassed from {@link VerletSpring3D}).
+     * 
+     * @param a
+     *            1st particle
+     * @param b
+     *            2nd particle
+     * @param len
+     *            rest length
+     * @param strength
+     * @return spring
+     */
+    protected final VerletSpring3D createSpring(VerletParticle3D a, VerletParticle3D b,
+            float len, float strength) {
+        return new VerletSpring3D(a, b, len, strength);
+    }
+
+    /**
+     * Returns the first particle of the string.
+     * 
+     * @return first particle
+     */
+    public VerletParticle3D getHead() {
+        return particles.get(0);
+    }
+
+    /**
+     * Returns number of particles of the string.
+     * 
+     * @return particle count
+     */
+    public int getNumParticles() {
+        return particles.size();
+    }
+
+    /**
+     * Returns last particle of the string.
+     * 
+     * @return last particle
+     */
+    public VerletParticle3D getTail() {
+        return particles.get(particles.size() - 1);
+    }
+}

data/src/toxi/physics3d/PullBackSpring3D.java

@@ -0,0 +1,50 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * 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;
+
+/**
+ * Creates a pullback spring (default restlength=0.5) between 2 particles and
+ * locks the first one given at the current position. The spring is only
+ * enforced if the current length of the spring exceeds the rest length. This
+ * behaviour is the opposite to the {@link VerletMinDistanceSpring3D}.
+ */
+class PullBackSpring3D extends VerletSpring3D {
+
+    public PullBackSpring3D(VerletParticle3D a, VerletParticle3D b, float strength) {
+        super(a, b, 0, strength);
+        a.lock();
+        setRestLength(0);
+    }
+
+    @Override
+    protected void update(boolean applyConstraints) {
+        if (b.distanceToSquared(a) > 0.5f) {
+            super.update(applyConstraints);
+        }
+    }
+}