toxiclibs 0.4.0 → 0.8.0

data/src/toxi/newmesh/MeshAttributeCompiler.java

@@ -0,0 +1,45 @@
+package toxi.newmesh;
+
+import toxi.util.datatypes.ItemIndex;
+
+/**
+ *
+ * @author tux
+ */
+public abstract class MeshAttributeCompiler {
+
+    /**
+     *
+     */
+    protected IndexedTriangleMesh mesh;
+
+    /**
+     *
+     * @param f
+     * @param index
+     * @param buf
+     * @param offset
+     */
+    public abstract void compileFace(AttributedFace f, ItemIndex<?> index,
+            float[] buf, int offset);
+
+    /**
+     *
+     * @return
+     */
+    public abstract ItemIndex<?> getIndex();
+
+    /**
+     *
+     * @return
+     */
+    public abstract int getStride();
+
+    /**
+     *
+     * @param mesh
+     */
+    public void setMesh(IndexedTriangleMesh mesh) {
+        this.mesh = mesh;
+    }
+}

data/src/toxi/newmesh/MeshFaceNormalCompiler.java

@@ -0,0 +1,52 @@
+package toxi.newmesh;
+
+import toxi.geom.Vec3D;
+import toxi.util.datatypes.ItemIndex;
+
+/**
+ *
+ * @author tux
+ */
+public class MeshFaceNormalCompiler extends MeshAttributeCompiler {
+
+    /**
+     *
+     * @param f
+     * @param index
+     * @param buf
+     * @param offset
+     */
+    @Override
+    public void compileFace(AttributedFace f, ItemIndex<?> index, float[] buf,
+            int offset) {
+        Vec3D v = (Vec3D) index.forID(f.normal);
+        buf[offset++] = v.x;
+        buf[offset++] = v.y;
+        buf[offset++] = v.z;
+        buf[offset++] = v.x;
+        buf[offset++] = v.y;
+        buf[offset++] = v.z;
+        buf[offset++] = v.x;
+        buf[offset++] = v.y;
+        buf[offset++] = v.z;
+    }
+
+    /**
+     *
+     * @return
+     */
+    @Override
+    public ItemIndex<?> getIndex() {
+        return mesh.fnormals;
+    }
+
+    /**
+     *
+     * @return
+     */
+    @Override
+    public int getStride() {
+        return 3;
+    }
+
+}

data/src/toxi/newmesh/MeshUVCompiler.java

@@ -0,0 +1,52 @@
+package toxi.newmesh;
+
+import toxi.geom.Vec2D;
+import toxi.util.datatypes.ItemIndex;
+
+/**
+ *
+ * @author tux
+ */
+public class MeshUVCompiler extends MeshAttributeCompiler {
+
+    /**
+     *
+     * @param f
+     * @param index
+     * @param buf
+     * @param offset
+     */
+    @Override
+    public void compileFace(AttributedFace f, ItemIndex<?> index, float[] buf,
+            int offset) {
+        int[] vn = f.attribs.get(IndexedTriangleMesh.ATTR_UVCOORDS);
+        Vec2D v = (Vec2D) index.forID(vn[0]);
+        buf[offset++] = v.x;
+        buf[offset++] = v.y;
+        v = (Vec2D) index.forID(vn[1]);
+        buf[offset++] = v.x;
+        buf[offset++] = v.y;
+        v = (Vec2D) index.forID(vn[2]);
+        buf[offset++] = v.x;
+        buf[offset++] = v.y;
+    }
+
+    /**
+     *
+     * @return
+     */
+    @Override
+    public ItemIndex<?> getIndex() {
+        return mesh.attributes.get(IndexedTriangleMesh.ATTR_UVCOORDS);
+    }
+
+    /**
+     *
+     * @return
+     */
+    @Override
+    public int getStride() {
+        return 2;
+    }
+
+}

data/src/toxi/newmesh/MeshVertexColorCompiler.java

@@ -0,0 +1,49 @@
+package toxi.newmesh;
+
+import toxi.color.ReadonlyTColor;
+import toxi.util.datatypes.ItemIndex;
+
+/**
+ *
+ * @author tux
+ */
+public class MeshVertexColorCompiler extends MeshAttributeCompiler {
+
+    /**
+     *
+     * @param f
+     * @param index
+     * @param buf
+     * @param offset
+     */
+    @Override
+    public void compileFace(AttributedFace f, ItemIndex<?> index, float[] buf,
+            int offset) {
+        int[] vn = f.attribs.get(IndexedTriangleMesh.ATTR_VCOLORS);
+        ReadonlyTColor c = (ReadonlyTColor) index.forID(vn[0]);
+        c.toRGBAArray(buf, offset);
+        c = (ReadonlyTColor) index.forID(vn[1]);
+        c.toRGBAArray(buf, offset + 4);
+        c = (ReadonlyTColor) index.forID(vn[2]);
+        c.toRGBAArray(buf, offset + 8);
+    }
+
+    /**
+     *
+     * @return
+     */
+    @Override
+    public ItemIndex<?> getIndex() {
+        return mesh.attributes.get(IndexedTriangleMesh.ATTR_VCOLORS);
+    }
+
+    /**
+     *
+     * @return
+     */
+    @Override
+    public int getStride() {
+        return 4;
+    }
+
+}

data/src/toxi/newmesh/MeshVertexCompiler.java

@@ -0,0 +1,54 @@
+package toxi.newmesh;
+
+import toxi.geom.Vec3D;
+import toxi.util.datatypes.ItemIndex;
+
+/**
+ *
+ * @author tux
+ */
+public class MeshVertexCompiler extends MeshAttributeCompiler {
+
+    /**
+     *
+     * @param f
+     * @param index
+     * @param buf
+     * @param offset
+     */
+    @Override
+    public void compileFace(AttributedFace f, ItemIndex<?> index, float[] buf,
+            int offset) {
+        Vec3D v = (Vec3D) index.forID(f.a);
+        buf[offset++] = v.x;
+        buf[offset++] = v.y;
+        buf[offset++] = v.z;
+        v = (Vec3D) index.forID(f.b);
+        buf[offset++] = v.x;
+        buf[offset++] = v.y;
+        buf[offset++] = v.z;
+        v = (Vec3D) index.forID(f.c);
+        buf[offset++] = v.x;
+        buf[offset++] = v.y;
+        buf[offset++] = v.z;
+    }
+
+    /**
+     *
+     * @return
+     */
+    @Override
+    public ItemIndex<?> getIndex() {
+        return mesh.vertices;
+    }
+
+    /**
+     *
+     * @return
+     */
+    @Override
+    public int getStride() {
+        return 3;
+    }
+
+}

data/src/toxi/newmesh/MeshVertexNormalCompiler.java

@@ -0,0 +1,55 @@
+package toxi.newmesh;
+
+import toxi.geom.Vec3D;
+import toxi.util.datatypes.ItemIndex;
+
+/**
+ *
+ * @author tux
+ */
+public class MeshVertexNormalCompiler extends MeshAttributeCompiler {
+
+    /**
+     *
+     * @param f
+     * @param index
+     * @param buf
+     * @param offset
+     */
+    @Override
+    public void compileFace(AttributedFace f, ItemIndex<?> index, float[] buf,
+            int offset) {
+        int[] vn = f.attribs.get(IndexedTriangleMesh.ATTR_VNORMALS);
+        Vec3D v = (Vec3D) index.forID(vn[0]);
+        buf[offset++] = v.x;
+        buf[offset++] = v.y;
+        buf[offset++] = v.z;
+        v = (Vec3D) index.forID(vn[1]);
+        buf[offset++] = v.x;
+        buf[offset++] = v.y;
+        buf[offset++] = v.z;
+        v = (Vec3D) index.forID(vn[2]);
+        buf[offset++] = v.x;
+        buf[offset++] = v.y;
+        buf[offset++] = v.z;
+    }
+
+    /**
+     *
+     * @return
+     */
+    @Override
+    public ItemIndex<?> getIndex() {
+        return mesh.attributes.get(IndexedTriangleMesh.ATTR_VNORMALS);
+    }
+
+    /**
+     *
+     * @return
+     */
+    @Override
+    public int getStride() {
+        return 3;
+    }
+
+}

data/src/toxi/newmesh/SpatialIndex.java

@@ -0,0 +1,78 @@
+package toxi.newmesh;
+
+import toxi.geom.Vec3D;
+import toxi.util.datatypes.UniqueItemIndex;
+
+/**
+ *
+ * @author tux
+ */
+public class SpatialIndex extends UniqueItemIndex<Vec3D> {
+
+    public float delta,
+
+    /**
+     *
+     */
+
+    /**
+     *
+     */
+    deltaSq;
+
+    /**
+     *
+     * @param delta
+     */
+    public SpatialIndex(float delta) {
+        setDelta(delta);
+    }
+
+    private int getClosestIndexed(Vec3D item) {
+        int c = -1;
+        float minD = deltaSq;
+        for (int i = 0, num = index.size(); i < num; i++) {
+            float d = index.get(i).distanceToSquared(item);
+            if (d < minD) {
+                minD = d;
+                c = i;
+            }
+        }
+        return c;
+    }
+
+    /**
+     *
+     * @return
+     */
+    public float getDelta() {
+        return delta;
+    }
+
+    /**
+     *
+     * @param item
+     * @return
+     */
+    @Override
+    public int index(Vec3D item) {
+        int id = getID(item);
+        if (id == -1) {
+            id = getClosestIndexed(item);
+        }
+        if (id != -1) {
+            return id;
+        } else {
+            return super.index(item);
+        }
+    }
+
+    /**
+     *
+     * @param delta
+     */
+    public final void setDelta(float delta) {
+        this.delta = delta;
+        this.deltaSq = delta * delta;
+    }
+}

data/src/toxi/physics2d/ParticlePath2D.java

@@ -0,0 +1,100 @@
+/*
+ *   __               .__       .__  ._____.           
+ * _/  |_  _______  __|__| ____ |  | |__\_ |__   ______
+ * \   __\/  _ \  \/  /  |/ ___\|  | |  || __ \ /  ___/
+ *  |  | (  <_> >    <|  \  \___|  |_|  || \_\ \\___ \ 
+ *  |__|  \____/__/\_ \__|\___  >____/__||___  /____  >
+ *                   \/       \/             \/     \/ 
+ *
+ * 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.List;
+
+import toxi.geom.Spline2D;
+import toxi.geom.Vec2D;
+
+/**
+ * This class is used as a builder to dynamically construct a
+ * {@link ParticleString2D} following a given spline path, sampled at a fixed
+ * frequency/step distance. This functionality is needed especially when working
+ * with various obstacles/mechanic constraints which the string should flow/wrap
+ * around.
+ */
+public class ParticlePath2D extends Spline2D {
+
+    List<VerletParticle2D> particles = new ArrayList<>();
+
+    /**
+     *
+     */
+    public ParticlePath2D() {
+        super();
+    }
+
+    /**
+     *
+     * @param points
+     */
+    public ParticlePath2D(List<Vec2D> points) {
+        super(points);
+    }
+
+    /**
+     * Creates particles along the spline at the fixed interval given. The
+     * precision of this interval will largely depend on the number of
+     * subdivision vertices created, but can be adjusted via the related
+     * parameter.
+     * 
+     * @param physics
+     *            physics instance
+     * @param subDiv
+     *            number spline segment subdivisions
+     * @param step
+     *            desired rest length between particles
+     * @param mass
+     *            desired particle mass
+     * @return list of particles
+     */
+    public List<VerletParticle2D> createParticles(VerletPhysics2D physics,
+            int subDiv, float step, float mass) {
+        particles.clear();
+        for (Vec2D v : toLineStrip2D(subDiv).getDecimatedVertices(step, true)) {
+            VerletParticle2D p = createSingleParticle(v, mass);
+            particles.add(p);
+            physics.addParticle(p);
+        }
+        return particles;
+    }
+
+    /**
+     * Extension point for creating a custom/sub-classed VerletParticle
+     * instance.
+     * 
+     * @param pos
+     * @param mass
+     * @return particle
+     */
+    protected VerletParticle2D createSingleParticle(Vec2D pos, float mass) {
+        return new VerletParticle2D(pos, mass);
+    }
+}