toxiclibs 0.2-java → 0.5.0-java

data/src/toxi/geom/VecMathUtil.java

@@ -0,0 +1,100 @@
+/*
+ * $RCSfile$
+ *
+ * Copyright 2004-2008 Sun Microsystems, Inc.  All Rights Reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Sun designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Sun in the LICENSE file that accompanied this code.
+ *
+ * This code 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 General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ *
+ * $Revision: 127 $
+ * $Date: 2008-02-28 20:18:51 +0000 (Thu, 28 Feb 2008) $
+ * $State$
+ */
+
+package toxi.geom;
+
+/**
+ * Utility vecmath class used when computing the hash code for vecmath objects
+ * containing float or double values. This fixes Issue 36.
+ */
+class VecMathUtil {
+
+    /**
+     * Returns the representation of the specified floating-point value
+     * according to the IEEE 754 floating-point "double format" bit layout,
+     * after first mapping -0.0 to 0.0. This method is identical to
+     * Double.doubleToLongBits(double) except that an integer value of 0L is
+     * returned for a floating-point value of -0.0. This is done for the purpose
+     * of computing a hash code that satisfies the contract of hashCode() and
+     * equals(). The equals() method in each vecmath class does a pair-wise "=="
+     * test on each floating-point field in the class (e.g., x, y, and z for a
+     * Tuple3d). Since 0.0 == -0.0 returns true, we must also return
+     * the same hash code for two objects, one of which has a field with a value
+     * of -0.0 and the other of which has a cooresponding field with a value of
+     * 0.0.
+     * 
+     * @param d
+     *            an input double precision floating-point number
+     * @return the integer bits representing that floating-point number, after
+     *         first mapping -0.0f to 0.0f
+     */
+    static long doubleToLongBits(double d) {
+        // Check for +0 or -0
+        if (d == 0.0) {
+            return 0L;
+        } else {
+            return Double.doubleToLongBits(d);
+        }
+    }
+
+    /**
+     * Returns the representation of the specified floating-point value
+     * according to the IEEE 754 floating-point "single format" bit layout,
+     * after first mapping -0.0 to 0.0. This method is identical to
+     * Float.floatToIntBits(float) except that an integer value of 0 is returned
+     * for a floating-point value of -0.0f. This is done for the purpose of
+     * computing a hash code that satisfies the contract of hashCode() and
+     * equals(). The equals() method in each vecmath class does a pair-wise "=="
+     * test on each floating-point field in the class (e.g., x, y, and z for a
+     * Tuple3f). Since 0.0f == -0.0f returns true, we must also return
+     * the same hash code for two objects, one of which has a field with a value
+     * of -0.0f and the other of which has a cooresponding field with a value of
+     * 0.0f.
+     * 
+     * @param f
+     *            an input floating-point number
+     * @return the integer bits representing that floating-point number, after
+     *         first mapping -0.0f to 0.0f
+     */
+    static int floatToIntBits(float f) {
+        if (f == 0.0f) {
+            return 0;
+        } else {
+            return Float.floatToIntBits(f);
+        }
+    }
+
+    /**
+     * Do not construct an instance of this class.
+     */
+    private VecMathUtil() {
+    }
+}

data/src/toxi/geom/XAxisCylinder.java

@@ -0,0 +1,64 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * 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 XAxisCylinder extends AxisAlignedCylinder {
+
+    /**
+     *
+     * @param pos
+     * @param radius
+     * @param length
+     */
+    public XAxisCylinder(ReadonlyVec3D pos, float radius, float length) {
+        super(pos, radius, length);
+    }
+
+    @Override
+    public boolean containsPoint(ReadonlyVec3D p) {
+        if (MathUtils.abs(p.x() - pos.x) < length * 0.5) {
+            float dy = p.y() - pos.y;
+            float dz = p.z() - pos.z;
+            if (Math.abs(dz * dz + dy * dy) < radiusSquared) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public Vec3D.Axis getMajorAxis() {
+        return Vec3D.Axis.X;
+    }
+}

data/src/toxi/geom/YAxisCylinder.java

@@ -0,0 +1,65 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * 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 YAxisCylinder extends AxisAlignedCylinder {
+
+    /**
+     *
+     * @param pos
+     * @param radius
+     * @param length
+     */
+    public YAxisCylinder(ReadonlyVec3D pos, float radius, float length) {
+        super(pos, radius, length);
+    }
+
+    @Override
+    public boolean containsPoint(ReadonlyVec3D p) {
+        if (MathUtils.abs(p.y() - pos.y) < length * 0.5) {
+            float dx = p.x() - pos.x;
+            float dz = p.z() - pos.z;
+            if (Math.abs(dz * dz + dx * dx) < radiusSquared) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public Vec3D.Axis getMajorAxis() {
+        return Vec3D.Axis.Y;
+    }
+
+}

data/src/toxi/geom/ZAxisCylinder.java

@@ -0,0 +1,64 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * 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 ZAxisCylinder extends AxisAlignedCylinder {
+
+    /**
+     *
+     * @param pos
+     * @param radius
+     * @param length
+     */
+    public ZAxisCylinder(ReadonlyVec3D pos, float radius, float length) {
+        super(pos, radius, length);
+    }
+
+    @Override
+    public boolean containsPoint(ReadonlyVec3D p) {
+        if (MathUtils.abs(p.z() - pos.z) < length * 0.5) {
+            float dx = p.x() - pos.x;
+            float dy = p.y() - pos.y;
+            if (Math.abs(dx * dx + dy * dy) < radiusSquared) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public Vec3D.Axis getMajorAxis() {
+        return Vec3D.Axis.Z;
+    }
+}

data/src/toxi/geom/mesh/BezierPatch.java

@@ -0,0 +1,200 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * 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.mesh;
+
+import toxi.geom.Vec3D;
+
+/**
+ * 4x4 bezier patch implementation with tesselation support (dynamic resolution)
+ * for generating triangle mesh representations.
+ */
+public class BezierPatch {
+
+    /**
+     * Computes a single point on the bezier surface given by the 2d array of
+     * control points. The desired point's coordinates have to be specified in
+     * UV space (range 0.0 .. 1.0). The implementation does not check or enforce
+     * the correct range of these coords and will not return valid points if the
+     * range is exceeded.
+     * 
+     * @param u
+     *            positive normalized U coordinate on the bezier surface
+     * @param v
+     *            positive normalized V coordinate on the bezier surface
+     * @param points
+     *            4x4 array defining the patch's control points
+     * @return point on surface
+     */
+    public static Vec3D computePointAt(float u, float v, Vec3D[][] points) {
+        final float u1 = 1 - u;
+        final float u1squared = u1 * u1 * 3 * u;
+        final float u1cubed = u1 * u1 * u1;
+        final float usquared = u * u;
+        final float v1 = 1 - v;
+        final float vsquared = v * v * 3;
+        final float v1squared = v1 * v1 * 3;
+        final float v1cubed = v1 * v1 * v1;
+        final float vcubed = v * v * v;
+
+        final float u1usq = u1 * usquared * 3;
+        final float usqu = u * usquared;
+        final float v1vsq = v1 * vsquared;
+        final float v1sqv = v1squared * v;
+
+        final Vec3D[] p0 = points[0];
+        final Vec3D[] p1 = points[1];
+        final Vec3D[] p2 = points[2];
+        final Vec3D[] p3 = points[3];
+
+        final float x = u1cubed
+                * (p0[0].x * v1cubed + p0[1].x * v1sqv + p0[2].x * v1vsq + p0[3].x
+                        * vcubed)
+                + u1squared
+                * (p1[0].x * v1cubed + p1[1].x * v1sqv + p1[2].x * v1vsq + p1[3].x
+                        * vcubed)
+                + u1usq
+                * (p2[0].x * v1cubed + p2[1].x * v1sqv + p2[2].x * v1vsq + p2[3].x
+                        * vcubed)
+                + usqu
+                * (p3[0].x * v1cubed + p3[1].x * v1sqv + p3[2].x * v1vsq + p3[3].x
+                        * vcubed);
+
+        final float y = u1cubed
+                * (p0[0].y * v1cubed + p0[1].y * v1sqv + p0[2].y * v1vsq + p0[3].y
+                        * vcubed)
+                + u1squared
+                * (p1[0].y * v1cubed + p1[1].y * v1sqv + p1[2].y * v1vsq + p1[3].y
+                        * vcubed)
+                + u1usq
+                * (p2[0].y * v1cubed + p2[1].y * v1sqv + p2[2].y * v1vsq + p2[3].y
+                        * vcubed)
+                + usqu
+                * (p3[0].y * v1cubed + p3[1].y * v1sqv + p3[2].y * v1vsq + p3[3].y
+                        * vcubed);
+
+        final float z = u1cubed
+                * (p0[0].z * v1cubed + p0[1].z * v1sqv + p0[2].z * v1vsq + p0[3].z
+                        * vcubed)
+                + u1squared
+                * (p1[0].z * v1cubed + p1[1].z * v1sqv + p1[2].z * v1vsq + p1[3].z
+                        * vcubed)
+                + u1usq
+                * (p2[0].z * v1cubed + p2[1].z * v1sqv + p2[2].z * v1vsq + p2[3].z
+                        * vcubed)
+                + usqu
+                * (p3[0].z * v1cubed + p3[1].z * v1sqv + p3[2].z * v1vsq + p3[3].z
+                        * vcubed);
+
+        return new Vec3D(x, y, z);
+    }
+
+    /**
+     *
+     */
+    public Vec3D[][] points;
+
+    /**
+     *
+     */
+    public BezierPatch() {
+        points = new Vec3D[4][4];
+        for (int i = 0; i < 4; i++) {
+            for (int j = 0; j < 4; j++) {
+                points[i][j] = new Vec3D();
+            }
+        }
+    }
+
+    /**
+     *
+     * @param points
+     */
+    public BezierPatch(Vec3D[][] points) {
+        this.points = points;
+    }
+
+    /**
+     *
+     * @param u
+     * @param v
+     * @return
+     */
+    public Vec3D computePointAt(float u, float v) {
+        return computePointAt(u, v, points);
+    }
+
+    /**
+     *
+     * @param x
+     * @param y
+     * @param p
+     * @return
+     */
+    public BezierPatch set(int x, int y, Vec3D p) {
+        points[y][x].set(p);
+        return this;
+    }
+
+    /**
+     *
+     * @param res
+     * @return
+     */
+    public Mesh3D toMesh(int res) {
+        return toMesh(null, res);
+    }
+
+    /**
+     *
+     * @param mesh
+     * @param res
+     * @return
+     */
+    public Mesh3D toMesh(Mesh3D mesh, int res) {
+        if (mesh == null) {
+            mesh = new TriangleMesh();
+        }
+        Vec3D[] curr = new Vec3D[res + 1];
+        Vec3D[] prev = new Vec3D[res + 1];
+        float r1 = 1f / res;
+        for (int y = 0; y <= res; y++) {
+            for (int x = 0; x <= res; x++) {
+                Vec3D p = computePointAt(x * r1, y * r1, points);
+                if (x > 0 && y > 0) {
+                    mesh.addFace(p, curr[x - 1], prev[x - 1]);
+                    mesh.addFace(p, prev[x - 1], prev[x]);
+                }
+                curr[x] = p;
+            }
+            Vec3D[] tmp = prev;
+            prev = curr;
+            curr = tmp;
+        }
+        return mesh;
+    }
+}