sigonasr2
/
jmonkeyengine
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Fixed TangentBinormalGenerator: Added grouping of vertices with the same position and normal. Re-added tangent orientation code to fix some visual artifacts.

Browse Source 
git-svn-id: https://jmonkeyengine.googlecode.com/svn/trunk@8645 75d07b2b-3a1a-0410-a2c5-0572b91ccdca
3.0
lex..82 13 years ago
parent 4ba21821a3
commit 687dad1a6b
1 changed files with 159 additions and 90 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 231
      engine/src/core/com/jme3/util/TangentBinormalGenerator.java

231
engine/src/core/com/jme3/util/TangentBinormalGenerator.java
Unescape View File

@ -49,13 +49,13 @@ import java.nio.FloatBuffer;
import java.nio.IntBuffer;
import java.util.ArrayList;
import java.util.List;
import java.util.logging.Logger;
import static com.jme3.util.BufferUtils.*;
/**
* @author Lex
*/
*
* @author Lex (Aleksey Nikiforov)
*/
public class TangentBinormalGenerator {
private static final float ZERO_TOLERANCE = 0.0000001f;
@ -68,36 +68,37 @@ public class TangentBinormalGenerator {
setToleranceAngle(45);
}
private static class VertexData {
public final Vector3f tangent = new Vector3f();
public final Vector3f binormal = new Vector3f();
public final List<TriangleData> triangles =
new ArrayList<TriangleData>();
private static class VertexInfo {
public final Vector3f position;
public final Vector3f normal;
public final ArrayList<Integer> indices = new ArrayList<Integer>();
public VertexData() {
public VertexInfo(Vector3f position, Vector3f normal) {
this.position = position;
this.normal = normal;
}
}
public static class TriangleData {
/** Collects all the triangle data for one vertex.
*/
private static class VertexData {
public final ArrayList<TriangleData> triangles = new ArrayList<TriangleData>();
public VertexData() { }
}
/** Keeps track of tangent, binormal, and normal for one triangle.
*/
public static class TriangleData {
public final Vector3f tangent;
public final Vector3f binormal;
public final Vector3f normal;
public int index0;
public int index1;
public int index2;
public TriangleData(Vector3f tangent, Vector3f binormal,
Vector3f normal,
int index0, int index1, int index2) {
public TriangleData(Vector3f tangent, Vector3f binormal, Vector3f normal) {
this.tangent = tangent;
this.binormal = binormal;
this.normal = normal;
this.index0 = index0;
this.index1 = index1;
this.index2 = index2;
}
}
@ -365,8 +366,7 @@ public class TangentBinormalGenerator {
return new TriangleData(
tangent,
binormal,
normal,
index[0], index[1], index[2]);
normal);
}
public static void setToleranceAngle(float angle) {
@ -378,8 +378,57 @@ public class TangentBinormalGenerator {
toleranceAngle = angle;
}
private static boolean approxEqual(Vector3f u, Vector3f v) {
float tolerance = 1E-4f;
return (FastMath.abs(u.x - v.x) < tolerance) &&
(FastMath.abs(u.y - v.y) < tolerance) &&
(FastMath.abs(u.z - v.z) < tolerance);
}
private static ArrayList<VertexInfo> linkVertices(Mesh mesh) {
ArrayList<VertexInfo> vertexMap = new ArrayList<VertexInfo>();
FloatBuffer vertexBuffer = (FloatBuffer) mesh.getBuffer(Type.Position).getData();
FloatBuffer normalBuffer = (FloatBuffer) mesh.getBuffer(Type.Normal).getData();
Vector3f position = new Vector3f();
Vector3f normal = new Vector3f();
final int size = vertexBuffer.capacity() / 3;
for (int i = 0; i < size; i++) {
populateFromBuffer(position, vertexBuffer, i);
populateFromBuffer(normal, normalBuffer, i);
boolean found = false;
for (int j = 0; j < vertexMap.size(); j++) {
VertexInfo vertexInfo = vertexMap.get(j);
if (approxEqual(vertexInfo.position, position) &&
approxEqual(vertexInfo.normal, normal))
{
vertexInfo.indices.add(i);
found = true;
break;
}
}
if (!found) {
VertexInfo vertexInfo = new VertexInfo(position.clone(), normal.clone());
vertexInfo.indices.add(i);
vertexMap.add(vertexInfo);
}
}
return vertexMap;
}
private static void processTriangleData(Mesh mesh, VertexData[] vertices,
boolean approxTangent) {
boolean approxTangent)
{
ArrayList<VertexInfo> vertexMap = linkVertices(mesh);
FloatBuffer normalBuffer = (FloatBuffer) mesh.getBuffer(Type.Normal).getData();
FloatBuffer tangents = BufferUtils.createFloatBuffer(vertices.length * 4);
@ -393,81 +442,96 @@ public class TangentBinormalGenerator {
Vector3f tangentUnit = new Vector3f();
Vector3f binormalUnit = new Vector3f();
for (int i = 0; i < vertices.length; i++) {
for (int k = 0; k < vertexMap.size(); k++) {
float wCoord = -1;
populateFromBuffer(givenNormal, normalBuffer, i);
VertexInfo vertexInfo = vertexMap.get(k);
givenNormal.set(vertexInfo.normal);
givenNormal.normalizeLocal();
VertexData currentVertex = vertices[i];
List<TriangleData> triangles = currentVertex.triangles;
TriangleData firstTriangle = vertices[vertexInfo.indices.get(0)].triangles.get(0);
// check tangent and binormal consistency
tangent.set(triangles.get(0).tangent);
tangent.set(firstTriangle.tangent);
tangent.normalizeLocal();
binormal.set(triangles.get(0).binormal);
binormal.set(firstTriangle.binormal);
binormal.normalizeLocal();
for (int j = 1; j < triangles.size(); j++) {
TriangleData triangleData = triangles.get(j);
for (int i : vertexInfo.indices) {
ArrayList<TriangleData> triangles = vertices[i].triangles;
tangentUnit.set(triangleData.tangent);
tangentUnit.normalizeLocal();
if (tangent.dot(tangentUnit) < toleranceDot) {
log.log(Level.WARNING,
"Angle between tangents exceeds tolerance "
+ "for vertex {0}.", i);
break;
}
for (int j = 0; j < triangles.size(); j++) {
TriangleData triangleData = triangles.get(j);
if (!approxTangent) {
binormalUnit.set(triangleData.binormal);
binormalUnit.normalizeLocal();
if (binormal.dot(binormalUnit) < toleranceDot) {
tangentUnit.set(triangleData.tangent);
tangentUnit.normalizeLocal();
if (tangent.dot(tangentUnit) < toleranceDot) {
log.log(Level.WARNING,
"Angle between binormals exceeds tolerance "
"Angle between tangents exceeds tolerance "
+ "for vertex {0}.", i);
break;
}
if (!approxTangent) {
binormalUnit.set(triangleData.binormal);
binormalUnit.normalizeLocal();
if (binormal.dot(binormalUnit) < toleranceDot) {
log.log(Level.WARNING,
"Angle between binormals exceeds tolerance "
+ "for vertex {0}.", i);
break;
}
}
}
}
// find average tangent
tangent.set(0, 0, 0);
binormal.set(0, 0, 0);
boolean flippedNormal = false;
for (int j = 0; j < triangles.size(); j++) {
TriangleData triangleData = triangles.get(j);
tangent.addLocal(triangleData.tangent);
binormal.addLocal(triangleData.binormal);
int triangleCount = 0;
for (int i : vertexInfo.indices) {
ArrayList<TriangleData> triangles = vertices[i].triangles;
triangleCount += triangles.size();
boolean flippedNormal = false;
for (int j = 0; j < triangles.size(); j++) {
TriangleData triangleData = triangles.get(j);
tangent.addLocal(triangleData.tangent);
binormal.addLocal(triangleData.binormal);
if (givenNormal.dot(triangleData.normal) < 0) {
flippedNormal = true;
if (givenNormal.dot(triangleData.normal) < 0) {
flippedNormal = true;
}
}
}
if (flippedNormal /*&& approxTangent*/) {
// Generated normal is flipped for this vertex,
// so binormal = normal.cross(tangent) will be flipped in the shader
// log.log(Level.WARNING,
// "Binormal is flipped for vertex {0}.", i);
if (flippedNormal /*&& approxTangent*/) {
// Generated normal is flipped for this vertex,
// so binormal = normal.cross(tangent) will be flipped in the shader
// log.log(Level.WARNING,
// "Binormal is flipped for vertex {0}.", i);
wCoord = 1;
wCoord = 1;
}
}
int blameVertex = vertexInfo.indices.get(0);
if (tangent.length() < ZERO_TOLERANCE) {
log.log(Level.WARNING,
"Shared tangent is zero for vertex {0}.", i);
"Shared tangent is zero for vertex {0}.", blameVertex);
// attempt to fix from binormal
if (binormal.length() >= ZERO_TOLERANCE) {
binormal.cross(givenNormal, tangent);
tangent.normalizeLocal();
} // if all fails use the tangent from the first triangle
else {
tangent.set(triangles.get(0).tangent);
tangent.set(firstTriangle.tangent);
}
} else {
tangent.divideLocal(triangles.size());
tangent.divideLocal(triangleCount);
}
tangentUnit.set(tangent);
@ -475,24 +539,24 @@ public class TangentBinormalGenerator {
if (Math.abs(Math.abs(tangentUnit.dot(givenNormal)) - 1)
< ZERO_TOLERANCE) {
log.log(Level.WARNING,
"Normal and tangent are parallel for vertex {0}.", i);
"Normal and tangent are parallel for vertex {0}.", blameVertex);
}
if (!approxTangent) {
if (binormal.length() < ZERO_TOLERANCE) {
log.log(Level.WARNING,
"Shared binormal is zero for vertex {0}.", i);
"Shared binormal is zero for vertex {0}.", blameVertex);
// attempt to fix from tangent
if (tangent.length() >= ZERO_TOLERANCE) {
givenNormal.cross(tangent, binormal);
binormal.normalizeLocal();
} // if all fails use the binormal from the first triangle
else {
binormal.set(triangles.get(0).binormal);
binormal.set(firstTriangle.binormal);
}
} else {
binormal.divideLocal(triangles.size());
binormal.divideLocal(triangleCount);
}
binormalUnit.set(binormal);
@ -500,32 +564,37 @@ public class TangentBinormalGenerator {
if (Math.abs(Math.abs(binormalUnit.dot(givenNormal)) - 1)
< ZERO_TOLERANCE) {
log.log(Level.WARNING,
"Normal and binormal are parallel for vertex {0}.", i);
"Normal and binormal are parallel for vertex {0}.", blameVertex);
}
if (Math.abs(Math.abs(binormalUnit.dot(tangentUnit)) - 1)
< ZERO_TOLERANCE) {
log.log(Level.WARNING,
"Tangent and binormal are parallel for vertex {0}.", i);
"Tangent and binormal are parallel for vertex {0}.", blameVertex);
}
}
if (approxTangent) {
// givenNormal.cross(tangent, binormal);
// binormal.cross(givenNormal, tangent);
tangent.normalizeLocal();
for (int i : vertexInfo.indices) {
if (approxTangent) {
// This calculation ensures that normal and tagent have a 90 degree angle.
// Removing this will lead to visual artifacts.
givenNormal.cross(tangent, binormal);
binormal.cross(givenNormal, tangent);
tangents.put((i * 4), tangent.x);
tangents.put((i * 4) + 1, tangent.y);
tangents.put((i * 4) + 2, tangent.z);
tangents.put((i * 4) + 3, wCoord);
} else {
tangents.put((i * 4), tangent.x);
tangents.put((i * 4) + 1, tangent.y);
tangents.put((i * 4) + 2, tangent.z);
tangents.put((i * 4) + 3, wCoord);
tangent.normalizeLocal();
// setInBuffer(binormal, binormals, i);
tangents.put((i * 4), tangent.x);
tangents.put((i * 4) + 1, tangent.y);
tangents.put((i * 4) + 2, tangent.z);
tangents.put((i * 4) + 3, wCoord);
} else {
tangents.put((i * 4), tangent.x);
tangents.put((i * 4) + 1, tangent.y);
tangents.put((i * 4) + 2, tangent.z);
tangents.put((i * 4) + 3, wCoord);
//setInBuffer(binormal, binormals, i);
}
}
}

Write Preview
Loading…
Cancel
Save