toxiclibs 0.2-java → 0.5.0-java

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

@@ -0,0 +1,224 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * 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 java.util.Collection;
+
+import toxi.geom.AABB;
+import toxi.geom.ReadonlyVec3D;
+import toxi.geom.Sphere;
+import toxi.geom.Vec2D;
+import toxi.geom.Vec3D;
+
+/**
+ * Common interface for 3D (triangle) mesh containers.
+ */
+public interface Mesh3D {
+
+    /**
+     * Adds the given 3 points as triangle face to the mesh. The assumed vertex
+     * order is anti-clockwise.
+     * 
+     * @param a
+     * @param b
+     * @param c
+     * @return 
+     */
+    public Mesh3D addFace(Vec3D a, Vec3D b, Vec3D c);
+
+    /**
+     * Adds the given 3 points as triangle face to the mesh and assigns the
+     * given texture coordinates to each vertex. The assumed vertex order is
+     * anti-clockwise.
+     * 
+     * @param a
+     * @param b
+     * @param c
+     * @param uvA
+     * @param uvB
+     * @param uvC
+     * @return itself
+     */
+    public Mesh3D addFace(Vec3D a, Vec3D b, Vec3D c, Vec2D uvA, Vec2D uvB,
+            Vec2D uvC);
+
+    /**
+     *
+     * @param a
+     * @param b
+     * @param c
+     * @param n
+     * @return
+     */
+    public Mesh3D addFace(Vec3D a, Vec3D b, Vec3D c, Vec3D n);
+
+    /**
+     *
+     * @param a
+     * @param b
+     * @param c
+     * @param n
+     * @param uvA
+     * @param uvB
+     * @param uvC
+     * @return
+     */
+    public Mesh3D addFace(Vec3D a, Vec3D b, Vec3D c, Vec3D n, Vec2D uvA,
+            Vec2D uvB, Vec2D uvC);
+
+    /**
+     *
+     * @param mesh
+     * @return
+     */
+    public Mesh3D addMesh(Mesh3D mesh);
+
+    /**
+     * Centers the mesh around the given pivot point (the centroid of its AABB).
+     * Method also updates & returns the new bounding box.
+     * 
+     * @param origin
+     *            new centroid or null (defaults to {0,0,0})
+     * @return 
+     */
+    public AABB center(ReadonlyVec3D origin);
+
+    /**
+     * Clears all counters, and vertex & face buffers.
+     * @return 
+     */
+    public Mesh3D clear();
+
+    /**
+     * Computes the mesh centroid, the average position of all vertices.
+     * 
+     * @return centre point
+     */
+    public Vec3D computeCentroid();
+
+    /**
+     * Re-calculates all face normals.
+     * @return 
+     */
+    public Mesh3D computeFaceNormals();
+
+    /**
+     * Computes the smooth vertex normals for the entire mesh.
+     * 
+     * @return itself
+     */
+    public Mesh3D computeVertexNormals();
+
+    /**
+     * Changes the vertex order of faces such that their normal is facing away
+     * from the mesh centroid.
+     * 
+     * @return itself
+     */
+    public Mesh3D faceOutwards();
+
+    /**
+     * Flips the vertex ordering between clockwise and anti-clockwise. Face
+     * normals are updated automatically too.
+     * 
+     * @return itself
+     */
+    public Mesh3D flipVertexOrder();
+
+    /**
+     * Flips all vertices along the Y axis and reverses the vertex ordering of
+     * all faces to compensate and keep the direction of normals intact.
+     * 
+     * @return itself
+     */
+    public Mesh3D flipYAxis();
+
+    /**
+     * Computes & returns the axis-aligned bounding box of the mesh.
+     * 
+     * @return bounding box
+     */
+    public AABB getBoundingBox();
+
+    /**
+     * Computes & returns the bounding sphere of the mesh. The origin of the
+     * sphere is the mesh's centroid.
+     * 
+     * @return bounding sphere
+     */
+    public Sphere getBoundingSphere();
+
+    /**
+     *
+     * @param p
+     * @return
+     */
+    public Vertex getClosestVertexToPoint(ReadonlyVec3D p);
+
+    /**
+     *
+     * @return
+     */
+    public Collection<Face> getFaces();
+
+    /**
+     * Returns the number of triangles used.
+     * 
+     * @return face count
+     */
+    public int getNumFaces();
+
+    /**
+     * Returns the number of actual vertices used (unique vertices).
+     * 
+     * @return vertex count
+     */
+    public int getNumVertices();
+
+    /**
+     *
+     * @return
+     */
+    public Collection<Vertex> getVertices();
+
+    /**
+     *
+     * @param name
+     * @param numV
+     * @param numF
+     * @return
+     */
+    public Mesh3D init(String name, int numV, int numF);
+
+    /**
+     *
+     * @param name
+     * @return
+     */
+    public Mesh3D setName(String name);
+}

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

@@ -0,0 +1,91 @@
+package toxi.geom.mesh;
+
+import toxi.geom.AABB;
+import toxi.geom.Intersector3D;
+import toxi.geom.IsectData3D;
+import toxi.geom.Ray3D;
+import toxi.geom.Vec3D;
+
+/**
+ *
+ * @author tux
+ */
+public class MeshIntersector implements Intersector3D {
+
+    private static final float EPS = 0.00001f;
+
+    private TriangleMesh mesh;
+    private AABB bounds;
+
+    private final IsectData3D isec;
+
+    /**
+     *
+     * @param mesh
+     */
+    public MeshIntersector(TriangleMesh mesh) {
+        setMesh(mesh);
+        this.isec = new IsectData3D();
+    }
+
+    @Override
+    public IsectData3D getIntersectionData() {
+        return isec;
+    }
+
+    @Override
+    public boolean intersectsRay(Ray3D ray) {
+        isec.isIntersection = false;
+        if (bounds.intersectsRay(ray, 0, Float.MAX_VALUE) != null) {
+            Vec3D dir = ray.getDirection();
+            float minD = Float.MAX_VALUE;
+            for (Face f : mesh.getFaces()) {
+                float d = intersectTriangle(f.a, f.b, f.c, ray, dir);
+                if (d >= 0.0 && d < minD) {
+                    isec.isIntersection = true;
+                    isec.normal = f.normal;
+                    minD = d;
+                }
+            }
+            if (isec.isIntersection) {
+                isec.pos = ray.getPointAtDistance(minD);
+                isec.dist = minD;
+                isec.dir = dir.getInverted();
+            }
+        }
+        return isec.isIntersection;
+    }
+
+    private float intersectTriangle(Vec3D a, Vec3D b, Vec3D c, Vec3D ro,
+            Vec3D dir) {
+        Vec3D e1 = b.sub(a);
+        Vec3D e2 = c.sub(a);
+        Vec3D pvec = dir.cross(e2);
+        float det = e1.dot(pvec);
+        if (det > -EPS && det < EPS) {
+            return -1;
+        }
+        float invDet = 1f / det;
+        Vec3D tvec = ro.sub(a);
+        float u = tvec.dot(pvec) * invDet;
+        if (u < 0.0 || u > 1.0) {
+            return -1;
+        }
+        Vec3D qvec = tvec.cross(e1);
+        float v = dir.dot(qvec) * invDet;
+        if (v < 0.0 || u + v > 1.0) {
+            return -1;
+        }
+        float t = e2.dot(qvec) * invDet;
+        return t;
+    }
+
+    /**
+     *
+     * @param mesh
+     */
+    public final void setMesh(TriangleMesh mesh) {
+        this.mesh = mesh;
+        this.bounds = mesh.getBoundingBox();
+    }
+}

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

@@ -0,0 +1,194 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * 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 java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.PrintWriter;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import toxi.geom.Vec3D;
+
+/**
+ * Extremely bare bones Wavefront OBJ 3D format exporter. Purely handles the
+ * writing of data to the .obj file, but does not have any form of mesh
+ * management. See {@link TriangleMesh} for details.
+ * 
+ * Needs to get some more TLC in future versions.
+ * 
+ * @see TriangleMesh#saveAsOBJ(OBJWriter)
+ */
+public class OBJWriter {
+
+    /**
+     *
+     */
+    public final String VERSION = "0.3";
+
+    /**
+     *
+     */
+    protected OutputStream objStream;
+
+    /**
+     *
+     */
+    protected PrintWriter objWriter;
+
+    /**
+     *
+     */
+    protected int numVerticesWritten = 0;
+
+    /**
+     *
+     */
+    protected int numNormalsWritten = 0;
+
+    /**
+     *
+     * @param stream
+     */
+    public void beginSave(OutputStream stream) {
+            objStream = stream;
+            handleBeginSave();
+    }
+
+    /**
+     *
+     * @param fn
+     */
+    public void beginSave(String fn) {
+        try {
+            objStream = new FileOutputStream(fn);
+            handleBeginSave();
+        } catch (FileNotFoundException ex) {
+            Logger.getLogger(OBJWriter.class.getName()).log(Level.SEVERE, null, ex);
+        }
+    }
+
+    /**
+     *
+     */
+    public void endSave() {
+        try {
+            objWriter.flush();
+            objWriter.close();
+            objStream.flush();
+            objStream.close();
+        } catch (IOException ex) {
+            Logger.getLogger(OBJWriter.class.getName()).log(Level.SEVERE, null, ex);
+        }
+    }
+
+    /**
+     *
+     * @param a
+     * @param b
+     * @param c
+     */
+    public void face(int a, int b, int c) {
+        objWriter.println("f " + a + " " + b + " " + c);
+    }
+
+    /**
+     *
+     */
+    public void faceList() {
+        objWriter.println("s off");
+    }
+
+    /**
+     *
+     * @param a
+     * @param b
+     * @param c
+     * @param na
+     * @param nb
+     * @param nc
+     */
+    public void faceWithNormals(int a, int b, int c, int na, int nb, int nc) {
+        objWriter.println("f " + a + "//" + na + " " + b + "//" + nb + " " + c
+                + "//" + nc);
+    }
+
+    /**
+     *
+     * @return
+     */
+    public int getCurrNormalOffset() {
+        return numNormalsWritten;
+    }
+
+    /**
+     *
+     * @return
+     */
+    public int getCurrVertexOffset() {
+        return numVerticesWritten;
+    }
+
+    /**
+     *
+     */
+    protected void handleBeginSave() {
+        objWriter = new PrintWriter(objStream);
+        objWriter.println("# generated by OBJExport v" + VERSION);
+        numVerticesWritten = 0;
+        numNormalsWritten = 0;
+    }
+
+    /**
+     *
+     * @param name
+     */
+    public void newObject(String name) {
+        objWriter.println("o " + name);
+    }
+
+    /**
+     *
+     * @param n
+     */
+    public void normal(Vec3D n) {
+        objWriter.println("vn " + n.x + " " + n.y + " " + n.z);
+        numNormalsWritten++;
+    }
+
+    /**
+     *
+     * @param v
+     */
+    public void vertex(Vec3D v) {
+        objWriter.println("v " + v.x + " " + v.y + " " + v.z);
+        numVerticesWritten++;
+    }
+}