toxiclibs 0.2-java → 0.5.0-java

data/src/toxi/geom/TriangleIntersector.java

@@ -0,0 +1,105 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * 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.geom;
+
+import toxi.math.MathUtils;
+
+/**
+ *
+ * @author tux
+ */
+public class TriangleIntersector implements Intersector3D {
+
+    /**
+     *
+     */
+    public Triangle3D triangle;
+    private IsectData3D isectData;
+
+    /**
+     *
+     */
+    public TriangleIntersector() {
+        this(new Triangle3D());
+    }
+
+    /**
+     *
+     * @param t
+     */
+    public TriangleIntersector(Triangle3D t) {
+        this.triangle = t;
+        this.isectData = new IsectData3D();
+    }
+
+    @Override
+    public IsectData3D getIntersectionData() {
+        return isectData;
+    }
+
+    /**
+     * @return the triangle
+     */
+    public Triangle3D getTriangle() {
+        return triangle;
+    }
+
+    @Override
+    public boolean intersectsRay(Ray3D ray) {
+        isectData.isIntersection = false;
+        Vec3D n = triangle.computeNormal();
+        float dotprod = n.dot(ray.dir);
+        if (dotprod < 0) {
+            Vec3D rt = ray.sub(triangle.a);
+            double t = -(double) (n.x * rt.x + n.y * rt.y + n.z * rt.z)
+                    / (n.x * ray.dir.x + n.y * ray.dir.y + n.z * ray.dir.z);
+            if (t >= MathUtils.EPS) {
+                Vec3D pos = ray.getPointAtDistance((float) t);
+                // check if pos is inside triangle
+                if (triangle.containsPoint(pos)) {
+                    isectData.isIntersection = true;
+                    isectData.pos = pos;
+                    isectData.normal = n;
+                    isectData.dist = (float) t;
+                    isectData.dir = isectData.pos.sub(ray).normalize();
+                }
+            }
+        }
+        return isectData.isIntersection;
+    }
+
+    /**
+     * @param tri
+     *            the triangle to set
+     * @return 
+     */
+    public TriangleIntersector setTriangle(Triangle3D tri) {
+        this.triangle = tri;
+        return this;
+    }
+}

data/src/toxi/geom/Vec2D.java

@@ -0,0 +1,1328 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * 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.geom;
+
+import java.util.Random;
+
+import javax.xml.bind.annotation.XmlAttribute;
+
+import toxi.math.InterpolateStrategy;
+import toxi.math.MathUtils;
+import toxi.math.ScaleMap;
+
+/**
+ * Comprehensive 2D vector class with additional basic intersection and
+ * collision detection features.
+ */
+public class Vec2D implements Comparable<ReadonlyVec2D>, ReadonlyVec2D {
+
+    /**
+     *
+     */
+    public static enum Axis {
+
+        /**
+         *
+         */
+        X(Vec2D.X_AXIS),
+
+        /**
+         *
+         */
+        Y(Vec2D.Y_AXIS);
+
+        private final ReadonlyVec2D vector;
+
+        private Axis(ReadonlyVec2D v) {
+            this.vector = v;
+        }
+
+        /**
+         *
+         * @return
+         */
+        public ReadonlyVec2D getVector() {
+            return vector;
+        }
+    }
+
+    /**
+     * Defines positive X axis
+     */
+    public static final ReadonlyVec2D X_AXIS = new Vec2D(1, 0);
+
+    /**
+     * Defines positive Y axis
+     */
+    public static final ReadonlyVec2D Y_AXIS = new Vec2D(0, 1);
+    ;
+
+    /** Defines the zero vector. */
+    public static final ReadonlyVec2D ZERO = new Vec2D();
+
+    /**
+     * Defines vector with both coords set to Float.MIN_VALUE. Useful for
+     * bounding box operations.
+     */
+    public static final ReadonlyVec2D MIN_VALUE = new Vec2D(Float.MIN_VALUE,
+            Float.MIN_VALUE);
+
+    /**
+     * Defines vector with both coords set to Float.MAX_VALUE. Useful for
+     * bounding box operations.
+     */
+    public static final ReadonlyVec2D MAX_VALUE = new Vec2D(Float.MAX_VALUE,
+            Float.MAX_VALUE);
+
+    /**
+     *
+     */
+    public static final ReadonlyVec2D NEG_MAX_VALUE = new Vec2D(
+            -Float.MAX_VALUE, -Float.MAX_VALUE);
+
+    /**
+     * Creates a new vector from the given angle in the XY plane.
+     *
+     * The resulting vector for theta=0 is equal to the positive X axis.
+     *
+     * @param theta
+     * @return new vector pointing into the direction of the passed in angle
+     */
+    public static final Vec2D fromTheta(float theta) {
+        return new Vec2D((float) Math.cos(theta), (float) Math.sin(theta));
+    }
+
+    /**
+     * Constructs a new vector consisting of the largest components of both
+     * vectors.
+     *
+     * @param b the b
+     * @param a the a
+     *
+     * @return result as new vector
+     */
+    public static final Vec2D max(ReadonlyVec2D a, ReadonlyVec2D b) {
+        return new Vec2D(MathUtils.max(a.x(), b.x()), MathUtils.max(a.y(),
+                b.y()));
+    }
+
+    /**
+     * Constructs a new vector consisting of the smallest components of both
+     * vectors.
+     *
+     * @param b comparing vector
+     * @param a the a
+     *
+     * @return result as new vector
+     */
+    public static final Vec2D min(ReadonlyVec2D a, ReadonlyVec2D b) {
+        return new Vec2D(MathUtils.min(a.x(), b.x()), MathUtils.min(a.y(),
+                b.y()));
+    }
+
+    /**
+     * Static factory method. Creates a new random unit vector using the Random
+     * implementation set as default for the {@link MathUtils} class.
+     *
+     * @return a new random normalized unit vector.
+     */
+    public static final Vec2D randomVector() {
+        return randomVector(MathUtils.RND);
+    }
+
+    /**
+     * Static factory method. Creates a new random unit vector using the given
+     * Random generator instance. I recommend to have a look at the
+     * https://uncommons-maths.dev.java.net library for a good choice of
+     * reliable and high quality random number generators.
+     *
+     * @param rnd
+     * @return a new random normalized unit vector.
+     */
+    public static final Vec2D randomVector(Random rnd) {
+        Vec2D v = new Vec2D(rnd.nextFloat() * 2 - 1, rnd.nextFloat() * 2 - 1);
+        return v.normalize();
+    }
+
+    /**
+     * X coordinate
+     */
+    @XmlAttribute(required = true)
+    public float x;
+
+    /**
+     * Y coordinate
+     */
+    @XmlAttribute(required = true)
+    public float y;
+
+    /**
+     * Creates a new zero vector
+     */
+    public Vec2D() {
+        x = y = 0;
+    }
+
+    /**
+     * Creates a new vector with the given coordinates
+     *
+     * @param x
+     * @param y
+     */
+    public Vec2D(float x, float y) {
+        this.x = x;
+        this.y = y;
+    }
+
+    /**
+     *
+     * @param v
+     */
+    public Vec2D(float[] v) {
+        this.x = v[0];
+        this.y = v[1];
+    }
+
+    /**
+     * Creates a new vector with the coordinates of the given vector
+     *
+     * @param v vector to be copied
+     */
+    public Vec2D(ReadonlyVec2D v) {
+        this.x = v.x();
+        this.y = v.y();
+    }
+
+    /**
+     *
+     * @return
+     */
+    public final Vec2D abs() {
+        x = MathUtils.abs(x);
+        y = MathUtils.abs(y);
+        return this;
+    }
+
+    @Override
+    public final Vec2D add(float a, float b) {
+        return new Vec2D(x + a, y + b);
+    }
+
+    @Override
+    public Vec2D add(ReadonlyVec2D v) {
+        return new Vec2D(x + v.x(), y + v.y());
+    }
+
+    /**
+     *
+     * @param v
+     * @return
+     */
+    public final Vec2D add(Vec2D v) {
+        return new Vec2D(x + v.x, y + v.y);
+    }
+
+    /**
+     * Adds vector {a,b,c} and overrides coordinates with result.
+     *
+     * @param a X coordinate
+     * @param b Y coordinate
+     * @return itself
+     */
+    public final Vec2D addSelf(float a, float b) {
+        x += a;
+        y += b;
+        return this;
+    }
+
+    /**
+     * Adds vector v and overrides coordinates with result.
+     *
+     * @param v vector to add
+     * @return itself
+     */
+    public final Vec2D addSelf(Vec2D v) {
+        x += v.x;
+        y += v.y;
+        return this;
+    }
+
+    @Override
+    public final float angleBetween(ReadonlyVec2D v) {
+        return (float) Math.acos(dot(v));
+    }
+
+    @Override
+    public final float angleBetween(ReadonlyVec2D v, boolean forceNormalize) {
+        float theta;
+        if (forceNormalize) {
+            theta = getNormalized().dot(v.getNormalized());
+        } else {
+            theta = dot(v);
+        }
+        return (float) Math.acos(MathUtils.clipNormalized(theta));
+    }
+
+    @Override
+    public Vec3D bisect(Vec2D b) {
+        Vec2D diff = this.sub(b);
+        Vec2D sum = this.add(b);
+        float dot = diff.dot(sum);
+        return new Vec3D(diff.x, diff.y, -dot / 2);
+    }
+
+    /**
+     * Sets all vector components to 0.
+     *
+     * @return itself
+     */
+    public final Vec2D clear() {
+        x = y = 0;
+        return this;
+    }
+
+    @Override
+    public int compareTo(ReadonlyVec2D o) {
+        if (this.equals(o)) {
+            return 0;
+        }
+        int result = (this.magSquared() < o.magSquared()) ? -1 : 1;
+        return result;
+    }
+
+    /**
+     * Constraints this vector to the perimeter of the given polygon. Unlike the
+     * {@link #constrain(Rect)} version of this method, this version DOES NOT
+     * check containment automatically. If you want to only constrain a point if
+     * its (for example) outside the polygon, then check containment with
+     * {@link Polygon2D#containsPoint(ReadonlyVec2D)} first before calling this
+     * method.
+     *
+     * @param poly
+     * @return itself
+     */
+    public Vec2D constrain(Polygon2D poly) {
+        float minD = Float.MAX_VALUE;
+        Vec2D q = null;
+        for (Line2D l : poly.getEdges()) {
+            Vec2D c = l.closestPointTo(this);
+            float d = c.distanceToSquared(this);
+            if (d < minD) {
+                q = c;
+                minD = d;
+            }
+        }
+        if (q != null) {
+            x = q.x;
+            y = q.y;
+        }
+        return this;
+    }
+
+    /**
+     * Forcefully fits the vector in the given rectangle.
+     *
+     * @param r
+     * @return itself
+     */
+    public Vec2D constrain(Rect r) {
+        x = MathUtils.clip(x, r.x, r.x + r.width);
+        y = MathUtils.clip(y, r.y, r.y + r.height);
+        return this;
+    }
+
+    /**
+     * Forcefully fits the vector in the given rectangle defined by the points.
+     *
+     * @param min
+     * @param max
+     * @return itself
+     */
+    public Vec2D constrain(Vec2D min, Vec2D max) {
+        x = MathUtils.clip(x, min.x, max.x);
+        y = MathUtils.clip(y, min.y, max.y);
+        return this;
+    }
+
+    @Override
+    public final Vec2D copy() {
+        return new Vec2D(this);
+    }
+
+    @Override
+    public float cross(ReadonlyVec2D v) {
+        return (x * v.y()) - (y * v.x());
+    }
+
+    @Override
+    public final float distanceTo(ReadonlyVec2D v) {
+        if (v != null) {
+            float dx = x - v.x();
+            float dy = y - v.y();
+            return (float) Math.sqrt(dx * dx + dy * dy);
+        } else {
+            return Float.NaN;
+        }
+    }
+
+    @Override
+    public final float distanceToSquared(ReadonlyVec2D v) {
+        if (v != null) {
+            float dx = x - v.x();
+            float dy = y - v.y();
+            return dx * dx + dy * dy;
+        } else {
+            return Float.NaN;
+        }
+    }
+
+    @Override
+    public final float dot(ReadonlyVec2D v) {
+        return x * v.x() + y * v.y();
+    }
+
+    /**
+     * Returns true if the Object v is of type ReadonlyVec2D and all of the data
+     * members of v are equal to the corresponding data members in this vector.
+     *
+     * @param obj the object with which the comparison is made
+     * @return true or false
+     */
+    
+    @Override
+    public boolean equals(Object obj) {
+        if (obj instanceof ReadonlyVec2D) {
+            final ReadonlyVec2D other = (ReadonlyVec2D) obj;
+            if (!((Float) x).equals(other.x())) {
+                return false;
+            }
+            return ((Float) y).equals(other.y());
+        }
+        return false;
+    }
+    
+    /**
+     * Returns a hash code value based on the data values in this object. Two
+     * different Vec2D objects with identical data values (i.e., Vec2D.equals
+     * returns true) will return the same hash code value. Two objects with
+     * different data members may return the same hash value, although this is
+     * not likely.
+     *
+     * @return the hash code value of this vector.
+     */
+
+    @Override
+    public int hashCode() {
+        int hash = 7;
+        hash = 97 * hash + Float.floatToIntBits(this.x);
+        hash = 97 * hash + Float.floatToIntBits(this.y);
+        return hash;
+    }
+
+    /**
+     * Returns true if all of the data members of ReadonlyVec2D v are equal to
+     * the corresponding data members in this vector.
+     *
+     * @param v the vector with which the comparison is made
+     * @return true or false
+     */
+    public boolean equals(ReadonlyVec2D v) {
+        final ReadonlyVec2D other = (ReadonlyVec2D) v;
+            if (!((Float) x).equals(other.x())) {
+                return false;
+            }
+            return ((Float) y).equals(other.y());
+        }
+
+    @Override
+    public boolean equalsWithTolerance(ReadonlyVec2D v, float tolerance) {
+        if (v instanceof ReadonlyVec2D){
+            float diff = x - v.x();
+            if (Float.isNaN(diff)) {
+                return false;
+            }
+            if ((diff < 0 ? -diff : diff) > tolerance) {
+                return false;
+            }
+            diff = y - v.y();
+            if (Float.isNaN(diff)) {
+                return false;
+            }
+            return ((diff < 0 ? -diff : diff) < tolerance);
+        } 
+            return false;        
+    }
+
+    /**
+     * Replaces the vector components with integer values of their current
+     * values
+     *
+     * @return itself
+     */
+    public final Vec2D floor() {
+        x = MathUtils.floor(x);
+        y = MathUtils.floor(y);
+        return this;
+    }
+
+    /**
+     * Replaces the vector components with the fractional part of their current
+     * values
+     *
+     * @return itself
+     */
+    public final Vec2D frac() {
+        x -= MathUtils.floor(x);
+        y -= MathUtils.floor(y);
+        return this;
+    }
+
+    /**
+     *
+     * @return
+     */
+    @Override
+    public final Vec2D getAbs() {
+        return new Vec2D(this).abs();
+    }
+
+    @Override
+    public Vec2D getCartesian() {
+        return copy().toCartesian();
+    }
+
+    /**
+     *
+     * @param id
+     * @return
+     */
+    @Override
+    public float getComponent(Axis id) {
+        switch (id) {
+            case X:
+                return x;
+            case Y:
+                return y;
+        }
+        return 0;
+    }
+
+    /**
+     *
+     * @param id
+     * @return
+     */
+    @Override
+    public final float getComponent(int id) {
+        switch (id) {
+            case 0:
+                return x;
+            case 1:
+                return y;
+        }
+        throw new IllegalArgumentException("index must be 0 or 1");
+    }
+
+    /**
+     *
+     * @param poly
+     * @return
+     */
+    public final Vec2D getConstrained(Polygon2D poly) {
+        return new Vec2D(this).constrain(poly);
+    }
+
+    @Override
+    public final Vec2D getConstrained(Rect r) {
+        return new Vec2D(this).constrain(r);
+    }
+
+    @Override
+    public final Vec2D getFloored() {
+        return new Vec2D(this).floor();
+    }
+
+    @Override
+    public final Vec2D getFrac() {
+        return new Vec2D(this).frac();
+    }
+
+    @Override
+    public final Vec2D getInverted() {
+        return new Vec2D(-x, -y);
+    }
+
+    @Override
+    public final Vec2D getLimited(float lim) {
+        if (magSquared() > lim * lim) {
+            return getNormalizedTo(lim);
+        }
+        return new Vec2D(this);
+    }
+
+    @Override
+    public Vec2D getMapped(ScaleMap map) {
+        return new Vec2D((float) map.getClippedValueFor(x),
+                (float) map.getClippedValueFor(y));
+    }
+
+    @Override
+    public final Vec2D getNormalized() {
+        return new Vec2D(this).normalize();
+    }
+
+    @Override
+    public final Vec2D getNormalizedTo(float len) {
+        return new Vec2D(this).normalizeTo(len);
+    }
+
+    /**
+     *
+     * @return
+     */
+    @Override
+    public final Vec2D getPerpendicular() {
+        return new Vec2D(this).perpendicular();
+    }
+
+    @Override
+    public Vec2D getPolar() {
+        return copy().toPolar();
+    }
+
+    /**
+     *
+     * @return
+     */
+    @Override
+    public final Vec2D getReciprocal() {
+        return copy().reciprocal();
+    }
+
+    /**
+     *
+     * @param normal
+     * @return
+     */
+    @Override
+    public final Vec2D getReflected(ReadonlyVec2D normal) {
+        return copy().reflect(normal);
+    }
+
+    @Override
+    public final Vec2D getRotated(float theta) {
+        return new Vec2D(this).rotate(theta);
+    }
+
+    @Override
+    public Vec2D getRoundedTo(float prec) {
+        return copy().roundTo(prec);
+    }
+
+    @Override
+    public Vec2D getSignum() {
+        return new Vec2D(this).signum();
+    }
+
+    @Override
+    public final float heading() {
+        return (float) Math.atan2(y, x);
+    }
+
+    @Override
+    public Vec2D interpolateTo(ReadonlyVec2D v, float f) {
+        return new Vec2D(x + (v.x() - x) * f, y + (v.y() - y) * f);
+    }
+
+    @Override
+    public Vec2D interpolateTo(ReadonlyVec2D v, float f, InterpolateStrategy s) {
+        return new Vec2D(s.interpolate(x, v.x(), f), s.interpolate(y, v.y(), f));
+    }
+
+    /**
+     *
+     * @param v
+     * @param f
+     * @return
+     */
+    public final Vec2D interpolateTo(Vec2D v, float f) {
+        return new Vec2D(x + (v.x - x) * f, y + (v.y - y) * f);
+    }
+
+    /**
+     *
+     * @param v
+     * @param f
+     * @param s
+     * @return
+     */
+    public Vec2D interpolateTo(Vec2D v, float f, InterpolateStrategy s) {
+        return new Vec2D(s.interpolate(x, v.x, f), s.interpolate(y, v.y, f));
+    }
+
+    /**
+     * Interpolates the vector towards the given target vector, using linear
+     * interpolation
+     *
+     * @param v target vector
+     * @param f interpolation factor (should be in the range 0..1)
+     * @return itself, result overrides current vector
+     */
+    public final Vec2D interpolateToSelf(ReadonlyVec2D v, float f) {
+        x += (v.x() - x) * f;
+        y += (v.y() - y) * f;
+        return this;
+    }
+
+    /**
+     * Interpolates the vector towards the given target vector, using the given
+     * {@link InterpolateStrategy}
+     *
+     * @param v target vector
+     * @param f interpolation factor (should be in the range 0..1)
+     * @param s InterpolateStrategy instance
+     * @return itself, result overrides current vector
+     */
+    public Vec2D interpolateToSelf(ReadonlyVec2D v, float f,
+            InterpolateStrategy s) {
+        x = s.interpolate(x, v.x(), f);
+        y = s.interpolate(y, v.y(), f);
+        return this;
+    }
+
+    /**
+     * Scales vector uniformly by factor -1 ( v = -v ), overrides coordinates
+     * with result
+     *
+     * @return itself
+     */
+    public final Vec2D invert() {
+        x *= -1;
+        y *= -1;
+        return this;
+    }
+
+    @Override
+    public boolean isInCircle(ReadonlyVec2D sO, float sR) {
+        float d = sub(sO).magSquared();
+        return (d <= sR * sR);
+    }
+    
+    /**
+     * Simplified
+     * @param r
+     * @return 
+     */
+
+    @Override
+    public boolean isInRectangle(Rect r) {
+        if (x < r.x || x > r.x + r.width) {
+            return false;
+        }
+        return (y >= r.y || y <= r.y + r.height); 
+    }
+
+    @Override
+    public boolean isInTriangle(Vec2D a, Vec2D b, Vec2D c) {
+        Vec2D v1 = sub(a).normalize();
+        Vec2D v2 = sub(b).normalize();
+        Vec2D v3 = sub(c).normalize();
+
+        double total_angles = Math.acos(v1.dot(v2));
+        total_angles += Math.acos(v2.dot(v3));
+        total_angles += Math.acos(v3.dot(v1));
+
+        return (MathUtils.abs((float) total_angles - MathUtils.TWO_PI) <= 0.005f);
+    }
+
+    @Override
+    public final boolean isMajorAxis(float tol) {
+        float ax = MathUtils.abs(x);
+        float ay = MathUtils.abs(y);
+        float itol = 1 - tol;
+        if (ax > itol) {
+            return (ay < tol);
+        } else if (ay > itol) {
+            return (ax < tol);
+        }
+        return false;
+    }
+
+    @Override
+    public final boolean isZeroVector() {
+        return MathUtils.abs(x) < MathUtils.EPS
+                && MathUtils.abs(y) < MathUtils.EPS;
+    }
+
+    /**
+     *
+     * @param j
+     * @return
+     */
+    public final Vec2D jitter(float j) {
+        return jitter(j, j);
+    }
+
+    /**
+     * Adds random jitter to the vector in the range -j ... +j using the default
+     * {@link Random} generator of {@link MathUtils}.
+     *
+     * @param jx maximum x jitter
+     * @param jy maximum y jitter
+     * @return itself
+     */
+    public final Vec2D jitter(float jx, float jy) {
+        x += MathUtils.normalizedRandom() * jx;
+        y += MathUtils.normalizedRandom() * jy;
+        return this;
+    }
+
+    /**
+     *
+     * @param rnd
+     * @param j
+     * @return
+     */
+    public final Vec2D jitter(Random rnd, float j) {
+        return jitter(rnd, j, j);
+    }
+
+    /**
+     *
+     * @param rnd
+     * @param jx
+     * @param jy
+     * @return
+     */
+    public final Vec2D jitter(Random rnd, float jx, float jy) {
+        x += MathUtils.normalizedRandom(rnd) * jx;
+        y += MathUtils.normalizedRandom(rnd) * jy;
+        return this;
+    }
+
+    /**
+     *
+     * @param rnd
+     * @param jv
+     * @return
+     */
+    public final Vec2D jitter(Random rnd, Vec2D jv) {
+        return jitter(rnd, jv.x, jv.y);
+    }
+
+    /**
+     *
+     * @param jv
+     * @return
+     */
+    public final Vec2D jitter(Vec2D jv) {
+        return jitter(jv.x, jv.y);
+    }
+
+    /**
+     * Limits the vector's magnitude to the length given
+     *
+     * @param lim new maximum magnitude
+     * @return itself
+     */
+    public final Vec2D limit(float lim) {
+        if (magSquared() > lim * lim) {
+            return normalize().scaleSelf(lim);
+        }
+        return this;
+    }
+
+    @Override
+    public final float magnitude() {
+        return (float) Math.sqrt(x * x + y * y);
+    }
+
+    @Override
+    public final float magSquared() {
+        return x * x + y * y;
+    }
+
+    @Override
+    public final Vec2D max(ReadonlyVec2D v) {
+        return new Vec2D(MathUtils.max(x, v.x()), MathUtils.max(y, v.y()));
+    }
+
+    /**
+     * Adjusts the vector components to the maximum values of both vectors
+     *
+     * @param v
+     * @return itself
+     */
+    public final Vec2D maxSelf(ReadonlyVec2D v) {
+        x = MathUtils.max(x, v.x());
+        y = MathUtils.max(y, v.y());
+        return this;
+    }
+
+    @Override
+    public final Vec2D min(ReadonlyVec2D v) {
+        return new Vec2D(MathUtils.min(x, v.x()), MathUtils.min(y, v.y()));
+    }
+
+    /**
+     * Adjusts the vector components to the minimum values of both vectors
+     *
+     * @param v
+     * @return itself
+     */
+    public final Vec2D minSelf(ReadonlyVec2D v) {
+        x = MathUtils.min(x, v.x());
+        y = MathUtils.min(y, v.y());
+        return this;
+    }
+
+    /**
+     * Normalizes the vector so that its magnitude = 1
+     *
+     * @return itself
+     */
+    public final Vec2D normalize() {
+        float mag = x * x + y * y;
+        if (mag > 0) {
+            mag = 1f / (float) Math.sqrt(mag);
+            x *= mag;
+            y *= mag;
+        }
+        return this;
+    }
+
+    /**
+     * Normalizes the vector to the given length.
+     *
+     * @param len desired length
+     * @return itself
+     */
+    public final Vec2D normalizeTo(float len) {
+        float mag = (float) Math.sqrt(x * x + y * y);
+        if (mag > 0) {
+            mag = len / mag;
+            x *= mag;
+            y *= mag;
+        }
+        return this;
+    }
+
+    /**
+     *
+     * @return
+     */
+    public final Vec2D perpendicular() {
+        float t = x;
+        x = -y;
+        y = t;
+        return this;
+    }
+
+    /**
+     *
+     * @return
+     */
+    public final float positiveHeading() {
+        double dist = Math.sqrt(x * x + y * y);
+        if (y >= 0) {
+            return (float) Math.acos(x / dist);
+        } else {
+            return (float) (Math.acos(-x / dist) + MathUtils.PI);
+        }
+    }
+
+    /**
+     *
+     * @return
+     */
+    public final Vec2D reciprocal() {
+        x = 1f / x;
+        y = 1f / y;
+        return this;
+    }
+
+    /**
+     *
+     * @param normal
+     * @return
+     */
+    public final Vec2D reflect(ReadonlyVec2D normal) {
+        return set(normal.scale(this.dot(normal) * 2).subSelf(this));
+    }
+
+    /**
+     * Rotates the vector by the given angle around the Z axis.
+     *
+     * @param theta
+     * @return itself
+     */
+    public final Vec2D rotate(float theta) {
+        float co = (float) Math.cos(theta);
+        float si = (float) Math.sin(theta);
+        float xx = co * x - si * y;
+        y = si * x + co * y;
+        x = xx;
+        return this;
+    }
+
+    /**
+     *
+     * @param prec
+     * @return
+     */
+    public Vec2D roundTo(float prec) {
+        x = MathUtils.roundTo(x, prec);
+        y = MathUtils.roundTo(y, prec);
+        return this;
+    }
+
+    @Override
+    public final Vec2D scale(float s) {
+        return new Vec2D(x * s, y * s);
+    }
+
+    @Override
+    public final Vec2D scale(float a, float b) {
+        return new Vec2D(x * a, y * b);
+    }
+
+    /**
+     *
+     * @param s
+     * @return
+     */
+    @Override
+    public final Vec2D scale(ReadonlyVec2D s) {
+        return s.copy().scaleSelf(this);
+    }
+
+    @Override
+    public final Vec2D scale(Vec2D s) {
+        return new Vec2D(x * s.x, y * s.y);
+    }
+
+    /**
+     * Scales vector uniformly and overrides coordinates with result
+     *
+     * @param s scale factor
+     * @return itself
+     */
+    public final Vec2D scaleSelf(float s) {
+        x *= s;
+        y *= s;
+        return this;
+    }
+
+    /**
+     * Scales vector non-uniformly by vector {a,b,c} and overrides coordinates
+     * with result
+     *
+     * @param a scale factor for X coordinate
+     * @param b scale factor for Y coordinate
+     * @return itself
+     */
+    public final Vec2D scaleSelf(float a, float b) {
+        x *= a;
+        y *= b;
+        return this;
+    }
+
+    /**
+     * Scales vector non-uniformly by vector v and overrides coordinates with
+     * result
+     *
+     * @param s scale vector
+     * @return itself
+     */
+    public final Vec2D scaleSelf(Vec2D s) {
+        x *= s.x;
+        y *= s.y;
+        return this;
+    }
+
+    /**
+     * Overrides coordinates with the given values
+     *
+     * @param x
+     * @param y
+     * @return itself
+     */
+    public final Vec2D set(float x, float y) {
+        this.x = x;
+        this.y = y;
+        return this;
+    }
+
+    /**
+     *
+     * @param v
+     * @return
+     */
+    public final Vec2D set(ReadonlyVec2D v) {
+        x = v.x();
+        y = v.y();
+        return this;
+    }
+
+    /**
+     * Overrides coordinates with the ones of the given vector
+     *
+     * @param v vector to be copied
+     * @return itself
+     */
+    public final Vec2D set(Vec2D v) {
+        x = v.x;
+        y = v.y;
+        return this;
+    }
+
+    /**
+     *
+     * @param id
+     * @param val
+     * @return
+     */
+    public final Vec2D setComponent(Axis id, float val) {
+        switch (id) {
+            case X:
+                x = val;
+                break;
+            case Y:
+                y = val;
+                break;
+        }
+        return this;
+    }
+
+    /**
+     *
+     * @param id
+     * @param val
+     * @return
+     */
+    public final Vec2D setComponent(int id, float val) {
+        switch (id) {
+            case 0:
+                x = val;
+                break;
+            case 1:
+                y = val;
+                break;
+            default:
+                throw new IllegalArgumentException(
+                        "component id needs to be 0 or 1");
+        }
+        return this;
+    }
+
+    /**
+     *
+     * @param x
+     * @return
+     */
+    public Vec2D setX(float x) {
+        this.x = x;
+        return this;
+    }
+
+    /**
+     *
+     * @param y
+     * @return
+     */
+    public Vec2D setY(float y) {
+        this.y = y;
+        return this;
+    }
+
+    /**
+     * Replaces all vector components with the signum of their original values.
+     * In other words if a components value was negative its new value will be
+     * -1, if zero => 0, if positive => +1
+     *
+     * @return itself
+     */
+    public final Vec2D signum() {
+        x = (x < 0 ? -1 : x == 0 ? 0 : 1);
+        y = (y < 0 ? -1 : y == 0 ? 0 : 1);
+        return this;
+    }
+
+    /**
+     * Rounds the vector to the closest major axis. Assumes the vector is
+     * normalized.
+     *
+     * @return itself
+     */
+    public final Vec2D snapToAxis() {
+        if (MathUtils.abs(x) < 0.5f) {
+            x = 0;
+        } else {
+            x = x < 0 ? -1 : 1;
+            y = 0;
+        }
+        if (MathUtils.abs(y) < 0.5f) {
+            y = 0;
+        } else {
+            y = y < 0 ? -1 : 1;
+            x = 0;
+        }
+        return this;
+    }
+
+    @Override
+    public final Vec2D sub(float a, float b) {
+        return new Vec2D(x - a, y - b);
+    }
+
+    /**
+     *
+     * @param v
+     * @return
+     */
+    @Override
+    public final Vec2D sub(ReadonlyVec2D v) {
+        return new Vec2D(x - v.x(), y - v.y());
+    }
+
+    @Override
+    public final Vec2D sub(Vec2D v) {
+        return new Vec2D(x - v.x, y - v.y);
+    }
+
+    /**
+     * Subtracts vector {a,b,c} and overrides coordinates with result.
+     *
+     * @param a X coordinate
+     * @param b Y coordinate
+     * @return itself
+     */
+    public final Vec2D subSelf(float a, float b) {
+        x -= a;
+        y -= b;
+        return this;
+    }
+
+    /**
+     * Subtracts vector v and overrides coordinates with result.
+     *
+     * @param v vector to be subtracted
+     * @return itself
+     */
+    public final Vec2D subSelf(Vec2D v) {
+        x -= v.x;
+        y -= v.y;
+        return this;
+    }
+
+    @Override
+    public final Vec2D tangentNormalOfEllipse(Vec2D eO, Vec2D eR) {
+        Vec2D p = this.sub(eO);
+
+        float xr2 = eR.x * eR.x;
+        float yr2 = eR.y * eR.y;
+
+        return new Vec2D(p.x / xr2, p.y / yr2).normalize();
+    }
+
+    @Override
+    public final Vec3D to3DXY() {
+        return new Vec3D(x, y, 0);
+    }
+
+    @Override
+    public final Vec3D to3DXZ() {
+        return new Vec3D(x, 0, y);
+    }
+
+    @Override
+    public final Vec3D to3DYZ() {
+        return new Vec3D(0, x, y);
+    }
+
+    /**
+     *
+     * @return
+     */
+    @Override
+    public float[] toArray() {
+        return new float[]{
+            x, y
+        };
+    }
+
+    /**
+     *
+     * @return
+     */
+    public final Vec2D toCartesian() {
+        float xx = (float) (x * Math.cos(y));
+        y = (float) (x * Math.sin(y));
+        x = xx;
+        return this;
+    }
+
+    /**
+     *
+     * @return
+     */
+    public final Vec2D toPolar() {
+        float r = (float) Math.sqrt(x * x + y * y);
+        y = (float) Math.atan2(y, x);
+        x = r;
+        return this;
+    }
+
+    /**
+     *
+     * @return
+     */
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder(32);
+        sb.append("{x:").append(x).append(", y:").append(y).append("}");
+        return sb.toString();
+    }
+
+    /**
+     *
+     * @return
+     */
+    @Override
+    public final float x() {
+        return x;
+    }
+
+    /**
+     *
+     * @return
+     */
+    @Override
+    public final float y() {
+        return y;
+    }
+}