toxiclibs 0.4.0 → 0.8.0

data/src/toxi/physics3d/constraints/SoftBoxConstraint.java

@@ -0,0 +1,87 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * 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.constraints;
+
+import java.util.LinkedList;
+import java.util.List;
+
+import toxi.geom.AABB;
+import toxi.geom.Vec3D.Axis;
+import toxi.physics3d.VerletParticle3D;
+
+/**
+ *
+ * @author tux
+ */
+public class SoftBoxConstraint implements ParticleConstraint3D {
+
+    /**
+     *
+     */
+    public AABB box;
+
+    /**
+     *
+     */
+    public List<Axis> axes = new LinkedList<Axis>();
+
+    /**
+     *
+     */
+    public float 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;
+    }
+
+    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);
+            }
+        }
+    }
+
+}

data/src/toxi/physics3d/constraints/SphereConstraint.java

@@ -0,0 +1,108 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * 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.constraints;
+
+import toxi.geom.Sphere;
+import toxi.geom.Vec3D;
+import toxi.physics3d.VerletParticle3D;
+
+/**
+ * This class implements a spherical constraint for 3D
+ * {@linkplain VerletParticle3D}s. The constraint can be configured in two ways: A
+ * bounding sphere not allowing particles to escape or alternatively does not
+ * allow particles to enter the space occupied by the sphere.
+ */
+public class SphereConstraint implements ParticleConstraint3D {
+
+    /**
+     *
+     */
+    public Sphere sphere;
+
+    /**
+     *
+     */
+    public boolean isBoundingSphere;
+
+    /**
+     *
+     */
+    public final static boolean INSIDE = true;
+
+    /**
+     *
+     */
+    public final static boolean OUTSIDE = false;
+
+    /**
+     * Creates a new instance using the sphere definition and constraint mode
+     * given.
+     * 
+     * @param sphere
+     *            sphere instance
+     * @param isBoundary
+     *            constraint mode. Use {@linkplain #INSIDE} or
+     *            {@linkplain #OUTSIDE} to specify constraint behaviour.
+     */
+    public SphereConstraint(Sphere sphere, boolean isBoundary) {
+        this.sphere = sphere;
+        this.isBoundingSphere = isBoundary;
+    }
+
+    /**
+     * Creates a new instance using the sphere definition and constraint mode
+     * given.
+     * 
+     * @param origin
+     *            sphere origin
+     * @param radius
+     *            sphere radius
+     * @param isBoundary
+     *            constraint mode. Use {@linkplain #INSIDE} or
+     *            {@linkplain #OUTSIDE} to specify constraint behaviour.
+     */
+    public SphereConstraint(Vec3D origin, float radius, boolean isBoundary) {
+        sphere = new Sphere(origin, radius);
+        this.isBoundingSphere = isBoundary;
+    }
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * toxi.physics.constraints.ParticleConstraint#apply(toxi.physics.VerletParticle
+     * )
+     */
+    public void apply(VerletParticle3D p) {
+        boolean isInside = sphere.containsPoint(p);
+        if ((isBoundingSphere && !isInside) || (!isBoundingSphere && isInside)) {
+            p.set(sphere.add(p.subSelf(sphere).normalizeTo(sphere.radius)));
+        }
+    }
+
+}

data/src/toxi/processing/ArrowModifier.java

@@ -0,0 +1,116 @@
+package toxi.processing;
+
+import toxi.geom.ReadonlyVec2D;
+import toxi.geom.Vec2D;
+import toxi.math.MathUtils;
+
+/**
+ * {@link Line2DRenderModifier} implementation to draw a line with arrow heads
+ * (or alternatively ONLY draw the heads). The size of the arrow heads can be
+ * customized as well as which ends they should be drawn at.
+ */
+public class ArrowModifier implements Line2DRenderModifier {
+
+    /**
+     * Arrow head type.
+     */
+    public enum Type {
+
+        /**
+         *
+         */
+        START,
+
+        /**
+         *
+         */
+        END,
+
+        /**
+         *
+         */
+        BOTH;
+    }
+
+    /**
+     *
+     */
+    public float length;
+
+    /**
+     *
+     */
+    public float theta;
+
+    /**
+     *
+     */
+    public Type type;
+
+    /**
+     *
+     */
+    public boolean doDrawLine;
+
+    /**
+     * Constructs a new modifier instance. The line itself is drawn as well.
+     * 
+     * @param length
+     *            length of arrow head
+     * @param theta
+     *            spread (in radians)
+     * @param type
+     *            type of arrow head(s)
+     */
+    public ArrowModifier(float length, float theta, Type type) {
+        this(length, theta, type, true);
+    }
+
+    /**
+     * Constructs a new modifier instance. If drawLine is set to true, the line
+     * itself is drawn as well. If false, only the arrow heads are drawn.
+     * 
+     * @param length
+     *            length of arrow head
+     * @param theta
+     *            spread (in radians)
+     * @param type
+     *            type of arrow head(s)
+     * @param drawLine
+     *            If false, only heads are drawn.
+     */
+    public ArrowModifier(float length, float theta, Type type, boolean drawLine) {
+        super();
+        this.length = length;
+        this.theta = theta;
+        this.type = type;
+        this.doDrawLine = drawLine;
+    }
+
+    /**
+     *
+     * @param gfx
+     * @param a
+     * @param b
+     */
+    @Override
+    public void apply(ToxiclibsSupport gfx, ReadonlyVec2D a, ReadonlyVec2D b) {
+        if (doDrawLine) {
+            gfx.line(a, b);
+        }
+        if (type == Type.START || type == Type.BOTH) {
+            Vec2D dir = b.sub(a).rotate(theta).normalizeTo(length);
+            gfx.line(a, a.add(dir));
+            dir.rotate(-theta * 2);
+            gfx.line(a, a.add(dir));
+        }
+        if (type == Type.END || type == Type.BOTH) {
+            Vec2D dir = b.sub(a).rotate(MathUtils.PI - theta)
+                    .normalizeTo(length);
+            gfx.line(b, b.add(dir));
+            dir.rotate(theta * 2);
+            gfx.line(b, b.add(dir));
+        }
+    }
+
+}

data/src/toxi/processing/DashedLineModifier.java

@@ -0,0 +1,48 @@
+package toxi.processing;
+
+import toxi.geom.Line2D;
+import toxi.geom.ReadonlyVec2D;
+import toxi.geom.Vec2D;
+
+/**
+ * {@link Line2DRenderModifier} implementation to draw a dashed line with
+ * customizable step length.
+ */
+public class DashedLineModifier implements Line2DRenderModifier {
+
+    /**
+     *
+     */
+    public float length;
+
+    /**
+     * Constructs a new instance
+     * 
+     * @param length
+     *            step length
+     */
+    public DashedLineModifier(float length) {
+        this.length = length;
+    }
+
+    /**
+     *
+     * @param gfx
+     * @param a
+     * @param b
+     */
+    @Override
+    public void apply(ToxiclibsSupport gfx, ReadonlyVec2D a, ReadonlyVec2D b) {
+        int i = 0;
+        Vec2D prev = null;
+        for (Vec2D p : new Line2D(a, b).splitIntoSegments(null, length, true)) {
+            if (i % 2 == 0) {
+                prev = p;
+            } else {
+                gfx.line(prev, p);
+            }
+            i++;
+        }
+    }
+
+}

data/src/toxi/processing/DeltaOrientationMapper.java

@@ -0,0 +1,57 @@
+package toxi.processing;
+
+import toxi.color.ReadonlyTColor;
+import toxi.color.ToneMap;
+import toxi.geom.Vec3D;
+
+/**
+ *
+ * @author tux
+ */
+public class DeltaOrientationMapper implements NormalMapper {
+
+    /**
+     *
+     */
+    protected Vec3D dir;
+
+    /**
+     *
+     */
+    protected ToneMap toneMap;
+
+    /**
+     *
+     */
+    protected double toneScale;
+
+    /**
+     *
+     * @param dir
+     * @param toneMap
+     */
+    public DeltaOrientationMapper(Vec3D dir, ToneMap toneMap) {
+        this.dir = dir;
+        setToneMap(toneMap);
+    }
+
+    /**
+     *
+     * @param normal
+     * @return
+     */
+    @Override
+    public ReadonlyTColor getRGBForNormal(Vec3D normal) {
+        float dot = (float) (dir.dot(normal) * toneScale + toneScale);
+        return toneMap.getToneFor(dot);
+    }
+
+    /**
+     *
+     * @param toneMap
+     */
+    public final void setToneMap(ToneMap toneMap) {
+        this.toneMap = toneMap;
+        this.toneScale = toneMap.map.getInputMedian();
+    }
+}

data/src/toxi/processing/Line2DRenderModifier.java

@@ -0,0 +1,18 @@
+package toxi.processing;
+
+import toxi.geom.ReadonlyVec2D;
+
+/**
+ *
+ * @author tux
+ */
+public interface Line2DRenderModifier {
+
+    /**
+     *
+     * @param gfx
+     * @param a
+     * @param b
+     */
+    public void apply(ToxiclibsSupport gfx, ReadonlyVec2D a, ReadonlyVec2D b);
+}

data/src/toxi/processing/MeshToVBO.java

@@ -0,0 +1,127 @@
+package toxi.processing;
+
+import processing.core.PApplet;
+import processing.core.PConstants;
+import processing.core.PImage;
+import processing.core.PShape;
+import toxi.geom.Matrix4x4;
+import toxi.geom.Vec3D;
+import toxi.geom.mesh.TriangleMesh;
+
+/**
+ *
+ * @author Martin Prout
+ */
+public class MeshToVBO {
+    final int DEFAULT_COLOR = -1; // white
+    private int fillColor;
+    private boolean wire = false;
+    private final PApplet app;
+    private final Matrix4x4 normalMap
+        = new Matrix4x4().translateSelf(128, 128, 128).scaleSelf(127);
+
+    /**
+     *
+     * @param app PApplet
+     */
+    public MeshToVBO(PApplet app) {
+        this.app = app;
+        this.fillColor = DEFAULT_COLOR;
+    }
+
+    public void wire(boolean show) {
+        this.wire = show;
+    }
+
+    /**
+     *
+     * @param col
+     */
+    public void fillColor(int col) {
+        this.fillColor = col;
+    }
+
+    /**
+     * Use default smooth (smooth = false) for cubes etc
+     *
+     * @param mesh Toxiclibs mesh
+     * @param smooth boolean
+     * @return
+     */
+    public PShape meshToShape(TriangleMesh mesh, boolean smooth) {
+        if (!wire) {
+            app.noStroke();
+        }
+        PShape retained = app.createShape();
+        retained.beginShape(PConstants.TRIANGLE);
+        retained.fill(fillColor);
+        if (smooth) {
+            mesh.faces.stream().map((f) -> {
+                retained.normal(f.a.normal.x, f.a.normal.y, f.a.normal.z);
+                retained.vertex(f.a.x, f.a.y, f.a.z);
+                retained.normal(f.b.normal.x, f.b.normal.y, f.b.normal.z);
+                retained.vertex(f.b.x, f.b.y, f.b.z);
+                retained.normal(f.c.normal.x, f.c.normal.y, f.c.normal.z);
+                return f;
+            }).forEach((f) -> {
+                retained.vertex(f.c.x, f.c.y, f.c.z);
+            });
+        } else {
+            if (wire) {
+                app.noFill();
+            }
+            mesh.faces.stream().map((f) -> {
+                retained.normal(f.normal.x, f.normal.y, f.normal.z);
+                retained.vertex(f.a.x, f.a.y, f.a.z);
+                retained.vertex(f.b.x, f.b.y, f.b.z);
+                return f;
+            }).forEach((f) -> {
+                retained.vertex(f.c.x, f.c.y, f.c.z);
+            });
+        }
+        retained.endShape();
+        return retained;
+    }
+
+    public PShape meshToColoredShape(TriangleMesh mesh) {
+        app.noStroke();
+        PShape gfx = app.createShape();
+        gfx.beginShape(PConstants.TRIANGLES);
+        mesh.faces.stream().map((f) -> {
+            Vec3D n = normalMap.applyTo(f.a.normal);
+            gfx.fill(n.x, n.y, n.z);
+            gfx.normal(f.a.normal.x, f.a.normal.y, f.a.normal.z);
+            gfx.vertex(f.a.x, f.a.y, f.a.z);
+            n = normalMap.applyTo(f.b.normal);
+            gfx.fill(n.x, n.y, n.z);
+            gfx.normal(f.b.normal.x, f.b.normal.y, f.b.normal.z);
+            gfx.vertex(f.b.x, f.b.y, f.b.z);
+            n = normalMap.applyTo(f.c.normal);
+            gfx.fill(n.x, n.y, n.z);
+            gfx.normal(f.c.normal.x, f.c.normal.y, f.c.normal.z);
+            return f;
+        }).forEach((f) -> {
+            gfx.vertex(f.c.x, f.c.y, f.c.z);
+        });
+        gfx.endShape();
+        return gfx;
+    }
+    
+    public PShape meshToTexturedShape(TriangleMesh mesh, PImage tex) {
+        PShape gfx = app.createShape();
+        gfx.beginShape(PConstants.TRIANGLE);
+        gfx.texture(tex);
+        mesh.faces.stream().map((f) -> {
+            gfx.normal(f.a.normal.x, f.a.normal.y, f.a.normal.z);
+            gfx.vertex(f.a.x, f.a.y, f.a.z, 0, 0);
+            gfx.normal(f.b.normal.x, f.b.normal.y, f.b.normal.z);
+            gfx.vertex(f.b.x, f.b.y, f.b.z, tex.width, 0);
+            gfx.normal(f.c.normal.x, f.c.normal.y, f.c.normal.z);
+            return f;
+        }).forEach((f) -> {
+            gfx.vertex(f.c.x, f.c.y, f.c.z, tex.width, tex.height);
+        });
+        gfx.endShape();
+        return gfx;
+    }
+}