/*
|
* Java port of Bullet (c) 2008 Martin Dvorak <jezek2@advel.cz>
|
*
|
* This source file is part of GIMPACT Library.
|
*
|
* For the latest info, see http://gimpact.sourceforge.net/
|
*
|
* Copyright (c) 2007 Francisco Leon Najera. C.C. 80087371.
|
* email: projectileman@yahoo.com
|
*
|
* This software is provided 'as-is', without any express or implied warranty.
|
* In no event will the authors be held liable for any damages arising from
|
* the use of this software.
|
*
|
* Permission is granted to anyone to use this software for any purpose,
|
* including commercial applications, and to alter it and redistribute it
|
* freely, subject to the following restrictions:
|
*
|
* 1. The origin of this software must not be misrepresented; you must not
|
* claim that you wrote the original software. If you use this software
|
* in a product, an acknowledgment in the product documentation would be
|
* appreciated but is not required.
|
* 2. Altered source versions must be plainly marked as such, and must not be
|
* misrepresented as being the original software.
|
* 3. This notice may not be removed or altered from any source distribution.
|
*/
|
|
package com.bulletphysics.extras.gimpact;
|
|
import com.bulletphysics.linearmath.Transform;
|
import com.bulletphysics.util.ObjectArrayList;
|
import cz.advel.stack.Stack;
|
import javax.vecmath.Vector3f;
|
import javax.vecmath.Vector4f;
|
|
/**
|
*
|
* @author jezek2
|
*/
|
public class PrimitiveTriangle {
|
|
private final ObjectArrayList<Vector3f> tmpVecList1 = new ObjectArrayList<Vector3f>(TriangleContact.MAX_TRI_CLIPPING);
|
private final ObjectArrayList<Vector3f> tmpVecList2 = new ObjectArrayList<Vector3f>(TriangleContact.MAX_TRI_CLIPPING);
|
private final ObjectArrayList<Vector3f> tmpVecList3 = new ObjectArrayList<Vector3f>(TriangleContact.MAX_TRI_CLIPPING);
|
|
{
|
for (int i=0; i<TriangleContact.MAX_TRI_CLIPPING; i++) {
|
tmpVecList1.add(new Vector3f());
|
tmpVecList2.add(new Vector3f());
|
tmpVecList3.add(new Vector3f());
|
}
|
}
|
|
public final Vector3f[] vertices = new Vector3f[3];
|
public final Vector4f plane = new Vector4f();
|
public float margin = 0.01f;
|
|
public PrimitiveTriangle() {
|
for (int i=0; i<vertices.length; i++) {
|
vertices[i] = new Vector3f();
|
}
|
}
|
|
public void set(PrimitiveTriangle tri) {
|
throw new UnsupportedOperationException();
|
}
|
|
public void buildTriPlane() {
|
Vector3f tmp1 = Stack.alloc(Vector3f.class);
|
Vector3f tmp2 = Stack.alloc(Vector3f.class);
|
|
Vector3f normal = Stack.alloc(Vector3f.class);
|
tmp1.sub(vertices[1], vertices[0]);
|
tmp2.sub(vertices[2], vertices[0]);
|
normal.cross(tmp1, tmp2);
|
normal.normalize();
|
|
plane.set(normal.x, normal.y, normal.z, vertices[0].dot(normal));
|
}
|
|
/**
|
* Test if triangles could collide.
|
*/
|
public boolean overlap_test_conservative(PrimitiveTriangle other) {
|
float total_margin = margin + other.margin;
|
// classify points on other triangle
|
float dis0 = ClipPolygon.distance_point_plane(plane, other.vertices[0]) - total_margin;
|
|
float dis1 = ClipPolygon.distance_point_plane(plane, other.vertices[1]) - total_margin;
|
|
float dis2 = ClipPolygon.distance_point_plane(plane, other.vertices[2]) - total_margin;
|
|
if (dis0 > 0.0f && dis1 > 0.0f && dis2 > 0.0f) {
|
return false; // classify points on this triangle
|
}
|
|
dis0 = ClipPolygon.distance_point_plane(other.plane, vertices[0]) - total_margin;
|
|
dis1 = ClipPolygon.distance_point_plane(other.plane, vertices[1]) - total_margin;
|
|
dis2 = ClipPolygon.distance_point_plane(other.plane, vertices[2]) - total_margin;
|
|
if (dis0 > 0.0f && dis1 > 0.0f && dis2 > 0.0f) {
|
return false;
|
}
|
return true;
|
}
|
|
/**
|
* Calcs the plane which is paralele to the edge and perpendicular to the triangle plane.
|
* This triangle must have its plane calculated.
|
*/
|
public void get_edge_plane(int edge_index, Vector4f plane) {
|
Vector3f e0 = vertices[edge_index];
|
Vector3f e1 = vertices[(edge_index + 1) % 3];
|
|
Vector3f tmp = Stack.alloc(Vector3f.class);
|
tmp.set(this.plane.x, this.plane.y, this.plane.z);
|
|
GeometryOperations.edge_plane(e0, e1, tmp, plane);
|
}
|
|
public void applyTransform(Transform t) {
|
t.transform(vertices[0]);
|
t.transform(vertices[1]);
|
t.transform(vertices[2]);
|
}
|
|
/**
|
* Clips the triangle against this.
|
*
|
* @param clipped_points must have MAX_TRI_CLIPPING size, and this triangle must have its plane calculated.
|
* @return the number of clipped points
|
*/
|
public int clip_triangle(PrimitiveTriangle other, ObjectArrayList<Vector3f> clipped_points) {
|
// edge 0
|
ObjectArrayList<Vector3f> temp_points = tmpVecList1;
|
|
Vector4f edgeplane = Stack.alloc(Vector4f.class);
|
|
get_edge_plane(0, edgeplane);
|
|
int clipped_count = ClipPolygon.plane_clip_triangle(edgeplane, other.vertices[0], other.vertices[1], other.vertices[2], temp_points);
|
|
if (clipped_count == 0) {
|
return 0;
|
}
|
ObjectArrayList<Vector3f> temp_points1 = tmpVecList2;
|
|
// edge 1
|
get_edge_plane(1, edgeplane);
|
|
clipped_count = ClipPolygon.plane_clip_polygon(edgeplane, temp_points, clipped_count, temp_points1);
|
|
if (clipped_count == 0) {
|
return 0; // edge 2
|
}
|
get_edge_plane(2, edgeplane);
|
|
clipped_count = ClipPolygon.plane_clip_polygon(edgeplane, temp_points1, clipped_count, clipped_points);
|
|
return clipped_count;
|
}
|
|
/**
|
* Find collision using the clipping method.
|
* This triangle and other must have their triangles calculated.
|
*/
|
public boolean find_triangle_collision_clip_method(PrimitiveTriangle other, TriangleContact contacts) {
|
float margin = this.margin + other.margin;
|
|
ObjectArrayList<Vector3f> clipped_points = tmpVecList3;
|
|
int clipped_count;
|
//create planes
|
// plane v vs U points
|
|
TriangleContact contacts1 = Stack.alloc(TriangleContact.class);
|
|
contacts1.separating_normal.set(plane);
|
|
clipped_count = clip_triangle(other, clipped_points);
|
|
if (clipped_count == 0) {
|
return false; // Reject
|
}
|
|
// find most deep interval face1
|
contacts1.merge_points(contacts1.separating_normal, margin, clipped_points, clipped_count);
|
if (contacts1.point_count == 0) {
|
return false; // too far
|
// Normal pointing to this triangle
|
}
|
contacts1.separating_normal.x *= -1.f;
|
contacts1.separating_normal.y *= -1.f;
|
contacts1.separating_normal.z *= -1.f;
|
|
// Clip tri1 by tri2 edges
|
TriangleContact contacts2 = Stack.alloc(TriangleContact.class);
|
contacts2.separating_normal.set(other.plane);
|
|
clipped_count = other.clip_triangle(this, clipped_points);
|
|
if (clipped_count == 0) {
|
return false; // Reject
|
}
|
|
// find most deep interval face1
|
contacts2.merge_points(contacts2.separating_normal, margin, clipped_points, clipped_count);
|
if (contacts2.point_count == 0) {
|
return false; // too far
|
|
// check most dir for contacts
|
}
|
if (contacts2.penetration_depth < contacts1.penetration_depth) {
|
contacts.copy_from(contacts2);
|
}
|
else {
|
contacts.copy_from(contacts1);
|
}
|
return true;
|
}
|
|
}
|
