toxiclibs 0.9.2 → 2.1.0

data/src/toxi/physics2d/VerletPhysics2D.java

@@ -1,448 +0,0 @@
-/*
- *   __               .__       .__  ._____.           
- * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
- * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
- *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
- *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
- *                   \/       \/             \/     \/ 
- *
- * 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.Iterator;
-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) {
-        for (VerletParticle2D p : list) {
-            p.addConstraint(c);
-        }
-    }
-
-    /**
-     *
-     * @param c
-     * @param list
-     */
-    public static void removeConstraintFromAll(ParticleConstraint2D c,
-            List<VerletParticle2D> list) {
-        for (VerletParticle2D p : list) {
-            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;
-        for (VerletParticle2D p : particles) {
-            if (hasGlobalConstraints) {
-                for (ParticleConstraint2D c : constraints) {
-                    c.apply(p);
-                }
-            }
-            if (p.bounds != null) {
-                p.constrain(p.bounds);
-            }
-            if (worldBounds != null) {
-                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);
-        for (VerletParticle2D p : particles) {
-            min.minSelf(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;
-        for (ParticleBehavior2D b : behaviors) {
-            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();
-            for (VerletParticle2D p : particles) {
-                index.index(p);
-            }
-        }
-    }
-
-    /**
-     * Updates all particle positions
-     */
-    protected void updateParticles() {
-        for (ParticleBehavior2D b : behaviors) {
-            if (index != null && b.supportsSpatialIndex()) {
-                b.applyWithIndex(index);
-            } else {
-                for (VerletParticle2D p : particles) {
-                    b.apply(p);
-                }
-            }
-        }
-        for (VerletParticle2D p : particles) {
-            p.scaleVelocity(drag);
-            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/toxi/physics2d/behaviors/AttractionBehavior2D.java

@@ -1,212 +0,0 @@
-/*
- *   __               .__       .__  ._____.           
- * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
- * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
- *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
- *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
- *                   \/       \/             \/     \/ 
- *
- * 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) {
-            for (Vec2D p : selection) {
-                temp.set(p);
-                apply((VerletParticle2D) p);
-                spaceHash.reindex(temp, p);
-            }
-        }
-    }
-
-    /**
-     *
-     * @param timeStep
-     */
-    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;
-    }
-
-}