/*
|
* Java port of Bullet (c) 2008 Martin Dvorak <jezek2@advel.cz>
|
*
|
* Bullet Continuous Collision Detection and Physics Library
|
* Copyright (c) 2003-2008 Erwin Coumans http://www.bulletphysics.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.collision.narrowphase;
|
|
import com.bulletphysics.collision.shapes.TriangleCallback;
|
import com.bulletphysics.linearmath.VectorUtil;
|
import cz.advel.stack.Stack;
|
import javax.vecmath.Vector3f;
|
|
/**
|
*
|
* @author jezek2
|
*/
|
public abstract class TriangleRaycastCallback extends TriangleCallback {
|
|
//protected final BulletStack stack = BulletStack.get();
|
|
public final Vector3f from = new Vector3f();
|
public final Vector3f to = new Vector3f();
|
|
public float hitFraction;
|
|
public TriangleRaycastCallback(Vector3f from, Vector3f to) {
|
this.from.set(from);
|
this.to.set(to);
|
this.hitFraction = 1f;
|
}
|
|
public void processTriangle(Vector3f[] triangle, int partId, int triangleIndex) {
|
Vector3f vert0 = triangle[0];
|
Vector3f vert1 = triangle[1];
|
Vector3f vert2 = triangle[2];
|
|
Vector3f v10 = Stack.alloc(Vector3f.class);
|
v10.sub(vert1, vert0);
|
|
Vector3f v20 = Stack.alloc(Vector3f.class);
|
v20.sub(vert2, vert0);
|
|
Vector3f triangleNormal = Stack.alloc(Vector3f.class);
|
triangleNormal.cross(v10, v20);
|
|
float dist = vert0.dot(triangleNormal);
|
float dist_a = triangleNormal.dot(from);
|
dist_a -= dist;
|
float dist_b = triangleNormal.dot(to);
|
dist_b -= dist;
|
|
if (dist_a * dist_b >= 0f) {
|
return; // same sign
|
}
|
|
float proj_length = dist_a - dist_b;
|
float distance = (dist_a) / (proj_length);
|
// Now we have the intersection point on the plane, we'll see if it's inside the triangle
|
// Add an epsilon as a tolerance for the raycast,
|
// in case the ray hits exacly on the edge of the triangle.
|
// It must be scaled for the triangle size.
|
|
if (distance < hitFraction) {
|
float edge_tolerance = triangleNormal.lengthSquared();
|
edge_tolerance *= -0.0001f;
|
Vector3f point = new Vector3f();
|
VectorUtil.setInterpolate3(point, from, to, distance);
|
{
|
Vector3f v0p = Stack.alloc(Vector3f.class);
|
v0p.sub(vert0, point);
|
Vector3f v1p = Stack.alloc(Vector3f.class);
|
v1p.sub(vert1, point);
|
Vector3f cp0 = Stack.alloc(Vector3f.class);
|
cp0.cross(v0p, v1p);
|
|
if (cp0.dot(triangleNormal) >= edge_tolerance) {
|
Vector3f v2p = Stack.alloc(Vector3f.class);
|
v2p.sub(vert2, point);
|
Vector3f cp1 = Stack.alloc(Vector3f.class);
|
cp1.cross(v1p, v2p);
|
if (cp1.dot(triangleNormal) >= edge_tolerance) {
|
Vector3f cp2 = Stack.alloc(Vector3f.class);
|
cp2.cross(v2p, v0p);
|
|
if (cp2.dot(triangleNormal) >= edge_tolerance) {
|
|
if (dist_a > 0f) {
|
hitFraction = reportHit(triangleNormal, distance, partId, triangleIndex);
|
}
|
else {
|
Vector3f tmp = Stack.alloc(Vector3f.class);
|
tmp.negate(triangleNormal);
|
hitFraction = reportHit(tmp, distance, partId, triangleIndex);
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
public abstract float reportHit(Vector3f hitNormalLocal, float hitFraction, int partId, int triangleIndex );
|
|
}
|