diff options
Diffstat (limited to 'src/alden')
| -rw-r--r-- | src/alden/CollidableObject.java | 62 | ||||
| -rw-r--r-- | src/alden/CollisionDetector.java | 204 | ||||
| -rw-r--r-- | src/alden/CollisionInfo.java | 13 | ||||
| -rw-r--r-- | src/alden/Sphere.java | 35 |
4 files changed, 226 insertions, 88 deletions
diff --git a/src/alden/CollidableObject.java b/src/alden/CollidableObject.java index f3e1ed9..eb3ff6a 100644 --- a/src/alden/CollidableObject.java +++ b/src/alden/CollidableObject.java @@ -45,7 +45,7 @@ public abstract class CollidableObject { angularVelocity = new Vector3f();
torqueAccumulator = new Vector3f();
inverseInertiaTensor = new Matrix3f();
- coefficientOfRestitution = 0.65f;
+ coefficientOfRestitution = 0.75f;
penetrationCorrection = 1.05f;
dynamicFriction = 0.02f;
TG = new TransformGroup();
@@ -58,7 +58,7 @@ public abstract class CollidableObject { protected void setShape(Node node) {
this.node = node;
TG.addChild(node);
- //TG.addChild(CollisionDetector.createShape(CollisionDetector.triangularize(node)));
+// TG.addChild(CollisionDetector.createShape(CollisionDetector.triangularize(node)));
}
public Group getGroup() {
@@ -79,6 +79,7 @@ public abstract class CollidableObject { velocity.scaleAdd(duration, forceAccumulator, velocity);
// The force vector is cleared.
forceAccumulator.set(0, 0, 0);
+
angularVelocity.scaleAdd(duration, torqueAccumulator, angularVelocity);
torqueAccumulator.set(0, 0, 0);
UnQuat4f tmp = new UnQuat4f(angularVelocity.x, angularVelocity.y, angularVelocity.z, 0);
@@ -89,10 +90,16 @@ public abstract class CollidableObject { }
protected void updateTransformGroup() {
+ Vector3f com = new Vector3f(-centerOfMass.x, -centerOfMass.y, -centerOfMass.z);
Transform3D tmp = new Transform3D();
- tmp.setRotation(orientation);
- tmp.setTranslation(position);
- TG.setTransform(tmp);
+ tmp.setTranslation(com);
+ Transform3D tmp2 = new Transform3D();
+ tmp2.setRotation(orientation);
+ com.negate();
+ com.add(position);
+ tmp2.setTranslation(com);
+ tmp2.mul(tmp);
+ TG.setTransform(tmp2);
clearCaches();
}
@@ -122,12 +129,15 @@ public abstract class CollidableObject { if (inverseInertiaTensorCache == null) {
inverseInertiaTensorCache = new Matrix3f();
inverseInertiaTensorCache.set(orientation);
- inverseInertiaTensorCache.invert();
- inverseInertiaTensorCache.mul(inverseInertiaTensor);
+ Matrix3f tmp = new Matrix3f(inverseInertiaTensor);
+ Matrix3f tmp2 = new Matrix3f(inverseInertiaTensorCache);
+ tmp2.invert();
+ tmp.mul(tmp2);
+ inverseInertiaTensorCache.mul(tmp);
}
return inverseInertiaTensorCache;
}
-
+
protected void clearCaches() {
vertexCache = null;
triangleCache = null;
@@ -144,7 +154,6 @@ public abstract class CollidableObject { float max = Float.NEGATIVE_INFINITY;
int count = 0;
for (CollisionInfo collision : collisions) {
-// float speed = collision.contactNormal.dot(previousVelocity) - collision.contactNormal.dot(other.previousVelocity);
Vector3f thisRelativeContactPosition = new Vector3f();
thisRelativeContactPosition.scaleAdd(-1, position, collision.contactPoint);
thisRelativeContactPosition.scaleAdd(-1, centerOfMass, thisRelativeContactPosition);
@@ -203,34 +212,47 @@ public abstract class CollidableObject { if (totalInverseMass == 0)
return;
+ Vector3f thisMovementUnit = new Vector3f();
+ thisMovementUnit.cross(thisRelativeContactPosition, ci.contactNormal);
+ getInverseInertiaTensor().transform(thisMovementUnit);
Vector3f thisAngularVelocityUnit = new Vector3f();
- thisAngularVelocityUnit.cross(thisRelativeContactPosition, ci.contactNormal);
- getInverseInertiaTensor().transform(thisAngularVelocityUnit);
- thisAngularVelocityUnit.cross(thisAngularVelocityUnit, thisRelativeContactPosition);
+ thisAngularVelocityUnit.cross(thisMovementUnit, thisRelativeContactPosition);
totalInverseMass += thisAngularVelocityUnit.dot(ci.contactNormal);
+ Vector3f otherMovementUnit = new Vector3f();
+ otherMovementUnit.cross(otherRelativeContactPosition, ci.contactNormal);
+ other.getInverseInertiaTensor().transform(otherMovementUnit);
Vector3f otherAngularVelocityUnit = new Vector3f();
- otherAngularVelocityUnit.cross(otherRelativeContactPosition, ci.contactNormal);
- other.getInverseInertiaTensor().transform(otherAngularVelocityUnit);
- otherAngularVelocityUnit.cross(otherAngularVelocityUnit, otherRelativeContactPosition);
+ otherAngularVelocityUnit.cross(otherMovementUnit, otherRelativeContactPosition);
totalInverseMass += otherAngularVelocityUnit.dot(ci.contactNormal);
-
+
Vector3f impulse = new Vector3f(ci.contactNormal);
impulse.scale(deltaClosingSpeed / totalInverseMass);
+
velocity.scaleAdd(inverseMass, impulse, velocity);
Vector3f tmp = new Vector3f();
tmp.cross(thisRelativeContactPosition, impulse);
- tmp.scale(thisAngularVelocityUnit.dot(ci.contactNormal));
getInverseInertiaTensor().transform(tmp);
angularVelocity.add(tmp);
- position.scaleAdd(-ci.penetration * penetrationCorrection * inverseMass / (inverseMass + other.inverseMass), ci.contactNormal, position);
+ position.scaleAdd(-ci.penetration * penetrationCorrection * inverseMass / totalInverseMass, ci.contactNormal, position);
+ thisMovementUnit.scale(-ci.penetration * penetrationCorrection / totalInverseMass);
+ UnQuat4f tmp2 = new UnQuat4f(thisMovementUnit.x, thisMovementUnit.y, thisMovementUnit.z, 0);
+ tmp2.scale(0.5f);
+ tmp2.mul(orientation);
+ orientation.add(tmp2);
+ orientation.normalize();
impulse.negate();
other.velocity.scaleAdd(other.inverseMass, impulse, other.velocity);
tmp.cross(otherRelativeContactPosition, impulse);
- tmp.scale(otherAngularVelocityUnit.dot(ci.contactNormal));
other.getInverseInertiaTensor().transform(tmp);
other.angularVelocity.add(tmp);
- other.position.scaleAdd(ci.penetration * penetrationCorrection * other.inverseMass / (inverseMass + other.inverseMass), ci.contactNormal, other.position);
+ other.position.scaleAdd(ci.penetration * penetrationCorrection * other.inverseMass / totalInverseMass, ci.contactNormal, other.position);
+ otherMovementUnit.scale(ci.penetration * penetrationCorrection / totalInverseMass);
+ tmp2.set(otherMovementUnit.x, otherMovementUnit.y, otherMovementUnit.z, 0);
+ tmp2.scale(0.5f);
+ tmp2.mul(other.orientation);
+ other.orientation.add(tmp2);
+ other.orientation.normalize();
}
}
diff --git a/src/alden/CollisionDetector.java b/src/alden/CollisionDetector.java index bb7817c..84682b8 100644 --- a/src/alden/CollisionDetector.java +++ b/src/alden/CollisionDetector.java @@ -1,4 +1,5 @@ package alden;
+
import java.util.ArrayList;
import javax.media.j3d.Appearance;
@@ -15,11 +16,15 @@ import javax.media.j3d.Transform3D; import javax.media.j3d.TriangleArray;
import javax.media.j3d.TriangleFanArray;
import javax.media.j3d.TriangleStripArray;
+import javax.vecmath.Matrix3f;
import javax.vecmath.Point3f;
import javax.vecmath.Tuple3f;
import javax.vecmath.Vector3f;
import tesseract.objects.HalfSpace;
+import tesseract.objects.Particle;
+import tesseract.objects.Polygon;
+import tesseract.objects.Sphere;
import com.sun.j3d.utils.geometry.Primitive;
@@ -228,21 +233,6 @@ public class CollisionDetector { }
return region;
}
-
- public boolean isAdjacent(Triangle other) {
- if (a.equals(other.a)) {
- if (b.equals(other.b) || b.equals(other.c) || c.equals(other.b) || c.equals(other.c))
- return true;
- } else if (a.equals(other.b)) {
- if (b.equals(other.a) || b.equals(other.c) || c.equals(other.a) || c.equals(other.c))
- return true;
- } else if (a.equals(other.c)) {
- if (b.equals(other.a) || b.equals(other.b) || c.equals(other.a) || c.equals(other.b))
- return true;
- } else if ((b.equals(other.b) || b.equals(other.c)) && (c.equals(other.b) || c.equals(other.c)))
- return true;
- return false;
- }
}
public static ArrayList<CollisionInfo> calculateCollisions(CollidableObject a, CollidableObject b) {
@@ -251,28 +241,72 @@ public class CollisionDetector { if (a instanceof HalfSpace) {
if (b instanceof HalfSpace)
return EMPTY_COLLISION_LIST;
+ if (b instanceof Particle)
+ return calculateCollisions((HalfSpace)a, (Particle)b);
if (b instanceof Sphere)
return calculateCollisions((HalfSpace)a, (Sphere)b);
return calculateCollisions((HalfSpace)a, b.getVertices());
}
- if (!a.getBounds().intersect(b.getBounds()))
- return EMPTY_COLLISION_LIST;
+ if (b instanceof HalfSpace) {
+ if (a instanceof Particle)
+ return flipContactNormals(calculateCollisions((HalfSpace)b, (Particle)a));
+ if (a instanceof Sphere)
+ return flipContactNormals(calculateCollisions((HalfSpace)b, (Sphere)a));
+ return flipContactNormals(calculateCollisions((HalfSpace)b, a.getVertices()));
+ }
+ if (a instanceof Particle) {
+ if (b instanceof Particle)
+ return EMPTY_COLLISION_LIST;
+ if (b instanceof Sphere)
+ return calculateCollisions((Particle)a, (Sphere)b);
+ if (b instanceof Polygon)
+ return calculateCollisions((Particle)a, (Polygon)b);
+ }
+ if (b instanceof Particle) {
+ if (a instanceof Sphere)
+ return flipContactNormals(calculateCollisions((Particle)b, (Sphere)a));
+ if (a instanceof Polygon)
+ return flipContactNormals(calculateCollisions((Particle)b, (Polygon)a));
+ }
if (a instanceof Sphere && b instanceof Sphere)
return calculateCollisions((Sphere)a, (Sphere)b);
+
+ if (!a.getBounds().intersect(b.getBounds()))
+ return EMPTY_COLLISION_LIST;
+
+ if (a instanceof Particle)
+ return calculateCollisions((Particle)a, b);
+ if (b instanceof Particle)
+ return flipContactNormals(calculateCollisions((Particle)b, a));
+ if (a instanceof Polygon)
+ return calculateCollisions((Polygon)a, b);
+ if (b instanceof Polygon)
+ return calculateCollisions((Polygon)b, a);
return CollisionDetector.calculateCollisions(a.getCollisionTriangles(), b.getCollisionTriangles());
}
+ private static ArrayList<CollisionInfo> calculateCollisions(HalfSpace a, Particle b) {
+ float penetration = a.intercept - a.normal.dot(b.position);
+ if (penetration < 0)
+ return EMPTY_COLLISION_LIST;
+ Vector3f contactPoint = new Vector3f();
+ contactPoint.scaleAdd(penetration, a.normal, b.position);
+ assert(Math.abs(a.normal.dot(contactPoint) - a.intercept) < 0.01);
+ ArrayList<CollisionInfo> collisions = new ArrayList<CollisionInfo>();
+ collisions.add(new CollisionInfo(contactPoint, new Vector3f(a.normal), penetration));
+ return collisions;
+ }
+
private static ArrayList<CollisionInfo> calculateCollisions(HalfSpace a, Sphere b) {
float penetration = b.radius - (a.normal.dot(b.position) - a.intercept);
- if (penetration >= 0) {
- Vector3f contactPoint = new Vector3f();
- contactPoint.scaleAdd(-(b.radius - penetration), a.normal, b.position);
- assert(Math.abs(a.normal.dot(contactPoint) - a.intercept) < 0.01);
- ArrayList<CollisionInfo> collisions = new ArrayList<CollisionInfo>();
- collisions.add(new CollisionInfo(contactPoint, a.normal, penetration));
- return collisions;
- }
- return EMPTY_COLLISION_LIST;
+ if (penetration < 0)
+ return EMPTY_COLLISION_LIST;
+ Vector3f contactPoint = new Vector3f();
+ contactPoint.scaleAdd(-(b.radius - penetration), a.normal, b.position);
+ assert(Math.abs(a.normal.dot(contactPoint) - a.intercept) < 0.01);
+ ArrayList<CollisionInfo> collisions = new ArrayList<CollisionInfo>();
+ collisions.add(new CollisionInfo(contactPoint, new Vector3f(a.normal), penetration));
+ return collisions;
}
private static ArrayList<CollisionInfo> calculateCollisions(HalfSpace a, ArrayList<Vector3f> setB) {
@@ -283,24 +317,124 @@ public class CollisionDetector { Vector3f contactPoint = new Vector3f();
contactPoint.scaleAdd(penetration, a.normal, vertex);
assert(Math.abs(a.normal.dot(contactPoint) - a.intercept) < 0.01);
- collisions.add(new CollisionInfo(contactPoint, a.normal, penetration));
+ collisions.add(new CollisionInfo(contactPoint, new Vector3f(a.normal), penetration));
}
}
return collisions;
}
+ private static ArrayList<CollisionInfo> calculateCollisions(Particle a, Sphere b) {
+ Vector3f delta = new Vector3f();
+ delta.scaleAdd(-1, a.position, b.position);
+ float penetration = b.radius - delta.length();
+ if (penetration < 0)
+ return EMPTY_COLLISION_LIST;
+
+ ArrayList<CollisionInfo> collisions = new ArrayList<CollisionInfo>();
+ delta.normalize();
+ Vector3f contactPoint = new Vector3f();
+ contactPoint.scaleAdd(-(b.radius - 0.5f * penetration), delta, b.position);
+ collisions.add(new CollisionInfo(contactPoint, delta, penetration));
+ return collisions;
+ }
+
+ private static ArrayList<CollisionInfo> calculateCollisions(Particle a, Polygon b) {
+ float penetration = b.intercept - b.normal.dot(a.position);
+ float previousPenetration = b.intercept - b.normal.dot(a.previousPosition);
+ if (Math.signum(penetration) == Math.signum(previousPenetration))
+ return EMPTY_COLLISION_LIST;
+
+ for (Triangle triangle : b.getCollisionTriangles()) {
+ Matrix3f tmp = new Matrix3f(a.previousPosition.x - a.position.x, triangle.b.x - triangle.a.x, triangle.c.x - triangle.a.x,
+ a.previousPosition.y - a.position.y, triangle.b.y - triangle.a.y, triangle.c.y - triangle.a.y,
+ a.previousPosition.z - a.position.z, triangle.b.z - triangle.a.z, triangle.c.z - triangle.a.z);
+ tmp.invert();
+ Vector3f intercept = new Vector3f();
+ intercept.scaleAdd(-1, triangle.a, a.previousPosition);
+ tmp.transform(intercept);
+
+ assert(intercept.x >= 0 && intercept.x <= 1);
+
+ if (intercept.y >= 0 && intercept.y <= 1 && intercept.z >= 0 && intercept.z <= 1 && (intercept.y + intercept.z) <= 1) {
+ Vector3f contactPoint = new Vector3f();
+ contactPoint.scaleAdd(-1, a.previousPosition, a.position);
+ contactPoint.scale(intercept.x);
+ contactPoint.add(a.previousPosition);
+ assert(Math.abs(b.normal.dot(contactPoint) - b.intercept) < 0.01);
+ Vector3f contactNormal = new Vector3f(b.normal);
+ if (penetration - previousPenetration > 0)
+ contactNormal.negate();
+ else
+ penetration = -penetration;
+ ArrayList<CollisionInfo> collisions = new ArrayList<CollisionInfo>();
+ collisions.add(new CollisionInfo(contactPoint, contactNormal, penetration));
+ return collisions;
+ }
+ }
+ return EMPTY_COLLISION_LIST;
+ }
+
+ private static ArrayList<CollisionInfo> calculateCollisions(Particle a, CollidableObject b) {
+ ArrayList<CollisionInfo> collisions = new ArrayList<CollisionInfo>();
+ for (Triangle triangle : b.getCollisionTriangles()) {
+ float penetration = triangle.intercept - triangle.normal.dot(a.position);
+ if (penetration < 0 || (!collisions.isEmpty() && penetration <= collisions.get(0).penetration))
+ continue;
+ float previousPenetration = triangle.intercept - triangle.normal.dot(a.previousPosition);
+ if (Math.signum(penetration) == Math.signum(previousPenetration))
+ continue;
+
+ Matrix3f tmp = new Matrix3f(a.previousPosition.x - a.position.x, triangle.b.x - triangle.a.x, triangle.c.x - triangle.a.x,
+ a.previousPosition.y - a.position.y, triangle.b.y - triangle.a.y, triangle.c.y - triangle.a.y,
+ a.previousPosition.z - a.position.z, triangle.b.z - triangle.a.z, triangle.c.z - triangle.a.z);
+ tmp.invert();
+ Vector3f intercept = new Vector3f();
+ intercept.scaleAdd(-1, triangle.a, a.previousPosition);
+ tmp.transform(intercept);
+
+ assert(intercept.x >= 0 && intercept.x <= 1);
+
+ if (intercept.y >= 0 && intercept.y <= 1 && intercept.z >= 0 && intercept.z <= 1 && (intercept.y + intercept.z) <= 1) {
+ Vector3f contactPoint = new Vector3f();
+ contactPoint.scaleAdd(-1, a.previousPosition, a.position);
+ contactPoint.scale(intercept.x);
+ contactPoint.add(a.previousPosition);
+ assert(Math.abs(triangle.normal.dot(contactPoint) - triangle.intercept) < 0.01);
+ Vector3f contactNormal = new Vector3f(triangle.normal);
+ if (penetration - previousPenetration > 0)
+ contactNormal.negate();
+ else
+ penetration = -penetration;
+ collisions.clear();
+ collisions.add(new CollisionInfo(contactPoint, contactNormal, penetration));
+ }
+ }
+ return collisions;
+ }
+
private static ArrayList<CollisionInfo> calculateCollisions(Sphere a, Sphere b) {
Vector3f delta = new Vector3f();
delta.scaleAdd(-1, a.position, b.position);
- float penetration = delta.length() - a.radius - b.radius;
- if (penetration > 0)
+ float penetration = a.radius + b.radius - delta.length();
+ if (penetration < 0)
return EMPTY_COLLISION_LIST;
ArrayList<CollisionInfo> collisions = new ArrayList<CollisionInfo>();
delta.normalize();
Vector3f contactPoint = new Vector3f();
- contactPoint.scaleAdd(a.radius + 0.5f * penetration, delta, a.position);
- collisions.add(new CollisionInfo(contactPoint, delta, -penetration));
+ contactPoint.scaleAdd(a.radius - 0.5f * penetration, delta, a.position);
+ collisions.add(new CollisionInfo(contactPoint, delta, penetration));
+ return collisions;
+ }
+
+ private static ArrayList<CollisionInfo> calculateCollisions(Polygon a, CollidableObject b) {
+ ArrayList<CollisionInfo> collisions = calculateCollisions(a.getCollisionTriangles(), b.getCollisionTriangles());
+ int size = collisions.size();
+ collisions.ensureCapacity(2 * size);
+ for (int i = 0; i < size; i++) {
+ collisions.add(collisions.get(i).clone());
+ collisions.get(collisions.size() - 1).contactNormal.negate();
+ }
return collisions;
}
@@ -315,6 +449,12 @@ public class CollisionDetector { return collisions;
}
+ private static ArrayList<CollisionInfo> flipContactNormals(ArrayList<CollisionInfo> collisions) {
+ for (CollisionInfo collision : collisions)
+ collision.contactNormal.negate();
+ return collisions;
+ }
+
public static ArrayList<Vector3f> extractVertices(Node node) {
ArrayList<Vector3f> vertices = new ArrayList<Vector3f>();
extractVertices(node, vertices);
@@ -343,7 +483,7 @@ public class CollisionDetector { for (int i = 0; i < group.numChildren(); i++)
extractVertices(group.getChild(i), vertices);
} else
- throw new IllegalArgumentException("Illegal node type for vertex extraction ");
+ throw new IllegalArgumentException("Illegal node type for vertex extraction");
}
private static void extractVertices(Geometry geometry, Transform3D transform, ArrayList<Vector3f> vertices) {
diff --git a/src/alden/CollisionInfo.java b/src/alden/CollisionInfo.java index 9cefcd0..dad74a5 100644 --- a/src/alden/CollisionInfo.java +++ b/src/alden/CollisionInfo.java @@ -2,7 +2,7 @@ package alden; import javax.vecmath.*;
@SuppressWarnings("restriction")
-public class CollisionInfo {
+public class CollisionInfo implements Cloneable {
public Vector3f contactPoint;
public Vector3f contactNormal;
public float penetration;
@@ -12,4 +12,15 @@ public class CollisionInfo { this.contactNormal = contactNormal;
this.penetration = penetration;
}
+
+ public CollisionInfo clone() {
+ try {
+ CollisionInfo copy = (CollisionInfo)super.clone();
+ copy.contactPoint = new Vector3f(contactPoint);
+ copy.contactNormal = new Vector3f(contactNormal);
+ return copy;
+ } catch (CloneNotSupportedException e) {
+ return null;
+ }
+ }
}
\ No newline at end of file diff --git a/src/alden/Sphere.java b/src/alden/Sphere.java deleted file mode 100644 index ddbaff4..0000000 --- a/src/alden/Sphere.java +++ /dev/null @@ -1,35 +0,0 @@ -package alden;
-
-import javax.media.j3d.*;
-import javax.vecmath.*;
-
-@SuppressWarnings("restriction")
-public class Sphere extends CollidableObject {
- protected float radius;
-
- public Sphere(float radius, Vector3f position) {
- this(1, radius, position);
- }
-
- public Sphere(float mass, float radius, Vector3f position) {
- super(mass);
- setShape(createShape(radius, 22));
- this.radius = radius;
- this.position.set(position);
- if (inverseMass != 0) {
- inverseInertiaTensor.m00 = 2f / 5 / inverseMass * radius * radius;
- inverseInertiaTensor.m11 = inverseInertiaTensor.m00;
- inverseInertiaTensor.m22 = inverseInertiaTensor.m00;
- inverseInertiaTensor.invert();
- }
- updateTransformGroup();
- }
-
- protected Node createShape(float radius, int divisions) {
- Appearance appearance = new Appearance();
- Material material = new Material();
- material.setDiffuseColor(0.7f, 0.7f, 1);
- appearance.setMaterial(material);
- return new com.sun.j3d.utils.geometry.Sphere(radius, com.sun.j3d.utils.geometry.Sphere.GENERATE_NORMALS, divisions, appearance);
- }
-}
|