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

- Added tangent transforms support for skinning (normal mapped models with bone animation had incorrect tangents during animation)

Browse Source 
- added a BindPoseTangent buffer type
- made generateBindPose generate a BindPoseTangent buffer if Tangent buffer is set in Mesh
- added a temp float array in TempVars to compute tangent skinning
- Generated bind pose for tangents after tangent generation in TangentBinormalGenerator

git-svn-id: https://jmonkeyengine.googlecode.com/svn/trunk@8563 75d07b2b-3a1a-0410-a2c5-0572b91ccdca
This commit is contained in:
rem..om 2011-10-31 14:18:35 +00:00
parent 40e32790d6
commit a5ff915fc1
5 changed files with 425 additions and 211 deletions

214
engine/src/core/com/jme3/animation/SkeletonControl.java

@ -75,21 +75,21 @@ public class SkeletonControl extends AbstractControl implements Cloneable {
* @param skeleton the skeleton
*/
@Deprecated
SkeletonControl(Mesh[] targets, Skeleton skeleton){
SkeletonControl(Mesh[] targets, Skeleton skeleton) {
this.skeleton = skeleton;
this.targets = targets;
}
private boolean isMeshAnimated(Mesh mesh){
private boolean isMeshAnimated(Mesh mesh) {
return mesh.getBuffer(Type.BindPosePosition) != null;
}
private Mesh[] findTargets(Node node){
private Mesh[] findTargets(Node node) {
Mesh sharedMesh = null;
ArrayList<Mesh> animatedMeshes = new ArrayList<Mesh>();
for (Spatial child : node.getChildren()){
if (!(child instanceof Geometry)){
for (Spatial child : node.getChildren()) {
if (!(child instanceof Geometry)) {
continue; // could be an attachment node, ignore.
}
@ -98,26 +98,26 @@ public class SkeletonControl extends AbstractControl implements Cloneable {
// is this geometry using a shared mesh?
Mesh childSharedMesh = geom.getUserData(UserData.JME_SHAREDMESH);
if (childSharedMesh != null){
if (childSharedMesh != null) {
// Don't bother with non-animated shared meshes
if (isMeshAnimated(childSharedMesh)){
if (isMeshAnimated(childSharedMesh)) {
// child is using shared mesh,
// so animate the shared mesh but ignore child
if (sharedMesh == null){
if (sharedMesh == null) {
sharedMesh = childSharedMesh;
}else if (sharedMesh != childSharedMesh){
} else if (sharedMesh != childSharedMesh) {
throw new IllegalStateException("Two conflicting shared meshes for " + node);
}
}
}else{
} else {
Mesh mesh = geom.getMesh();
if (isMeshAnimated(mesh)){
if (isMeshAnimated(mesh)) {
animatedMeshes.add(mesh);
}
}
}
if (sharedMesh != null){
if (sharedMesh != null) {
animatedMeshes.add(sharedMesh);
}
@ -125,12 +125,12 @@ public class SkeletonControl extends AbstractControl implements Cloneable {
}
@Override
public void setSpatial(Spatial spatial){
public void setSpatial(Spatial spatial) {
super.setSpatial(spatial);
if (spatial != null){
if (spatial != null) {
Node node = (Node) spatial;
targets = findTargets(node);
}else{
} else {
targets = null;
}
}
@ -163,7 +163,7 @@ public class SkeletonControl extends AbstractControl implements Cloneable {
}
void resetToBind() {
for (Mesh mesh : targets){
for (Mesh mesh : targets) {
if (isMeshAnimated(mesh)) {
VertexBuffer bi = mesh.getBuffer(Type.BoneIndex);
ByteBuffer bib = (ByteBuffer) bi.getData();
@ -182,6 +182,19 @@ public class SkeletonControl extends AbstractControl implements Cloneable {
nb.clear();
bpb.clear();
bnb.clear();
//reseting bind tangents if there is a bind tangent buffer
VertexBuffer bindTangents = mesh.getBuffer(Type.BindPoseTangent);
if (bindTangents != null) {
VertexBuffer tangents = mesh.getBuffer(Type.Tangent);
FloatBuffer tb = (FloatBuffer) tangents.getData();
FloatBuffer btb = (FloatBuffer) bindTangents.getData();
tb.clear();
btb.clear();
tb.put(btb).clear();
}
pb.put(bpb).clear();
nb.put(bnb).clear();
}
@ -251,7 +264,6 @@ public class SkeletonControl extends AbstractControl implements Cloneable {
// public void setSkeleton(Skeleton skeleton) {
// this.skeleton = skeleton;
// }
/**
* returns the targets meshes of this control
* @return
@ -267,8 +279,31 @@ public class SkeletonControl extends AbstractControl implements Cloneable {
// public void setTargets(Mesh[] targets) {
// this.targets = targets;
// }
/**
* Update the mesh according to the given transformation matrices
* @param mesh then mesh
* @param offsetMatrices the transformation matrices to apply
*/
private void softwareSkinUpdate(Mesh mesh, Matrix4f[] offsetMatrices) {
VertexBuffer tb = mesh.getBuffer(Type.Tangent);
if (tb == null) {
//if there are no tangents use the classic skinning
applySkinning(mesh, offsetMatrices);
} else {
//if there are tangents use the skinning with tangents
applySkinningTangents(mesh, offsetMatrices, tb);
}
}
/**
* Method to apply skinning transforms to a mesh's buffers
* @param mesh the mesh
* @param offsetMatrices the offset matices to apply
*/
private void applySkinning(Mesh mesh, Matrix4f[] offsetMatrices) {
int maxWeightsPerVert = mesh.getMaxNumWeights();
if (maxWeightsPerVert <= 0) {
throw new IllegalStateException("Max weights per vert is incorrectly set!");
@ -304,7 +339,7 @@ public class SkeletonControl extends AbstractControl implements Cloneable {
float[] normBuf = vars.skinNormals;
int iterations = (int) FastMath.ceil(fvb.capacity() / ((float) posBuf.length));
int bufLength = posBuf.length * 3;
int bufLength = posBuf.length;
for (int i = iterations - 1; i >= 0; i--) {
// read next set of positions and normals from native buffer
bufLength = Math.min(posBuf.length, fvb.remaining());
@ -359,7 +394,146 @@ public class SkeletonControl extends AbstractControl implements Cloneable {
vb.updateData(fvb);
nb.updateData(fnb);
// mesh.updateBound();
}
/**
* Specific method for skinning with tangents to avoid cluttering the classic skinning calculation with
* null checks that would slow down the process even if tangents don't have to be computed.
* Also the iteration has additional indexes since tangent has 4 components instead of 3 for pos and norm
* @param maxWeightsPerVert maximum number of weights per vertex
* @param mesh the mesh
* @param offsetMatrices the offsetMaytrices to apply
* @param tb the tangent vertexBuffer
*/
private void applySkinningTangents(Mesh mesh, Matrix4f[] offsetMatrices, VertexBuffer tb) {
int maxWeightsPerVert = mesh.getMaxNumWeights();
if (maxWeightsPerVert <= 0) {
throw new IllegalStateException("Max weights per vert is incorrectly set!");
}
int fourMinusMaxWeights = 4 - maxWeightsPerVert;
// NOTE: This code assumes the vertex buffer is in bind pose
// resetToBind() has been called this frame
VertexBuffer vb = mesh.getBuffer(Type.Position);
FloatBuffer fvb = (FloatBuffer) vb.getData();
fvb.rewind();
VertexBuffer nb = mesh.getBuffer(Type.Normal);
FloatBuffer fnb = (FloatBuffer) nb.getData();
fnb.rewind();
FloatBuffer ftb = (FloatBuffer) tb.getData();
ftb.rewind();
// get boneIndexes and weights for mesh
ByteBuffer ib = (ByteBuffer) mesh.getBuffer(Type.BoneIndex).getData();
FloatBuffer wb = (FloatBuffer) mesh.getBuffer(Type.BoneWeight).getData();
ib.rewind();
wb.rewind();
float[] weights = wb.array();
byte[] indices = ib.array();
int idxWeights = 0;
TempVars vars = TempVars.get();
float[] posBuf = vars.skinPositions;
float[] normBuf = vars.skinNormals;
float[] tanBuf = vars.skinTangents;
int iterations = (int) FastMath.ceil(fvb.capacity() / ((float) posBuf.length));
int bufLength = 0;
int tanLength = 0;
for (int i = iterations - 1; i >= 0; i--) {
// read next set of positions and normals from native buffer
bufLength = Math.min(posBuf.length, fvb.remaining());
tanLength = Math.min(tanBuf.length, ftb.remaining());
fvb.get(posBuf, 0, bufLength);
fnb.get(normBuf, 0, bufLength);
ftb.get(tanBuf, 0, tanLength);
int verts = bufLength / 3;
int idxPositions = 0;
//tangents has their own index because of the 4 components
int idxTangents = 0;
// iterate vertices and apply skinning transform for each effecting bone
for (int vert = verts - 1; vert >= 0; vert--) {
float nmx = normBuf[idxPositions];
float vtx = posBuf[idxPositions++];
float nmy = normBuf[idxPositions];
float vty = posBuf[idxPositions++];
float nmz = normBuf[idxPositions];
float vtz = posBuf[idxPositions++];
float tnx = tanBuf[idxTangents++];
float tny = tanBuf[idxTangents++];
float tnz = tanBuf[idxTangents++];
//skipping the 4th component of the tangent since it doesn't have to be transformed
idxTangents++;
float rx = 0, ry = 0, rz = 0, rnx = 0, rny = 0, rnz = 0, rtx = 0, rty = 0, rtz = 0;
for (int w = maxWeightsPerVert - 1; w >= 0; w--) {
float weight = weights[idxWeights];
Matrix4f mat = offsetMatrices[indices[idxWeights++]];
rx += (mat.m00 * vtx + mat.m01 * vty + mat.m02 * vtz + mat.m03) * weight;
ry += (mat.m10 * vtx + mat.m11 * vty + mat.m12 * vtz + mat.m13) * weight;
rz += (mat.m20 * vtx + mat.m21 * vty + mat.m22 * vtz + mat.m23) * weight;
rnx += (nmx * mat.m00 + nmy * mat.m01 + nmz * mat.m02) * weight;
rny += (nmx * mat.m10 + nmy * mat.m11 + nmz * mat.m12) * weight;
rnz += (nmx * mat.m20 + nmy * mat.m21 + nmz * mat.m22) * weight;
rtx += (tnx * mat.m00 + tny * mat.m01 + tnz * mat.m02) * weight;
rty += (tnx * mat.m10 + tny * mat.m11 + tnz * mat.m12) * weight;
rtz += (tnx * mat.m20 + tny * mat.m21 + tnz * mat.m22) * weight;
}
idxWeights += fourMinusMaxWeights;
idxPositions -= 3;
normBuf[idxPositions] = rnx;
posBuf[idxPositions++] = rx;
normBuf[idxPositions] = rny;
posBuf[idxPositions++] = ry;
normBuf[idxPositions] = rnz;
posBuf[idxPositions++] = rz;
idxTangents -= 4;
tanBuf[idxTangents++] = rtx;
tanBuf[idxTangents++] = rty;
tanBuf[idxTangents++] = rtz;
//once again skipping the 4th component of the tangent
idxTangents++;
}
fvb.position(fvb.position() - bufLength);
fvb.put(posBuf, 0, bufLength);
fnb.position(fnb.position() - bufLength);
fnb.put(normBuf, 0, bufLength);
ftb.position(ftb.position() - tanLength);
ftb.put(tanBuf, 0, tanLength);
}
vars.release();
vb.updateData(fvb);
nb.updateData(fnb);
tb.updateData(ftb);
}
@Override

11
engine/src/core/com/jme3/scene/Mesh.java

@ -334,6 +334,17 @@ public class Mesh implements Savable, Cloneable {
setBuffer(bindNorm);
norm.setUsage(Usage.Stream);
}
VertexBuffer tangents = getBuffer(Type.Tangent);
if (tangents != null) {
VertexBuffer bindTangents = new VertexBuffer(Type.BindPoseTangent);
bindTangents.setupData(Usage.CpuOnly,
4,
Format.Float,
BufferUtils.clone(tangents.getData()));
setBuffer(bindTangents);
tangents.setUsage(Usage.Stream);
}
}
}

13
engine/src/core/com/jme3/scene/VertexBuffer.java

@ -94,7 +94,9 @@ public class VertexBuffer extends NativeObject implements Savable, Cloneable {
Color,
/**
* Tangent vector, normalized (3 floats)
* Tangent vector, normalized (4 floats) (x,y,z,w)
* the w component is called the binormal parity, is not normalized and is either 1f or -1f
* It's used to compuste the direction on the binormal verctor on the GPU at render time.
*/
Tangent,
@ -140,6 +142,15 @@ public class VertexBuffer extends NativeObject implements Savable, Cloneable {
*/
BindPoseNormal,
/**
* Initial vertex tangents, used with animation.
* Should have the same format and size as {@link Type#Tangent}.
* If used with software skinning, the usage should be
* {@link Usage#CpuOnly}, and the buffer should be allocated
* on the heap.
*/
BindPoseTangent,
/**
* Bone weights, used with animation (4 floats).
* If used with software skinning, the usage should be

164
engine/src/core/com/jme3/util/TangentBinormalGenerator.java

@ -29,9 +29,11 @@
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package com.jme3.util;
import com.jme3.scene.VertexBuffer;
import com.jme3.scene.VertexBuffer.Format;
import com.jme3.scene.VertexBuffer.Usage;
import java.util.logging.Level;
import com.jme3.scene.mesh.IndexBuffer;
import com.jme3.scene.Geometry;
@ -59,7 +61,6 @@ public class TangentBinormalGenerator {
private static final float ZERO_TOLERANCE = 0.0000001f;
private static final Logger log = Logger.getLogger(
TangentBinormalGenerator.class.getName());
private static float toleranceAngle;
private static float toleranceDot;
@ -68,17 +69,18 @@ public class TangentBinormalGenerator {
}
private static class VertexData {
public final Vector3f tangent = new Vector3f();
public final Vector3f binormal = new Vector3f();
public final List<TriangleData> triangles =
new ArrayList<TriangleData>();
public VertexData() {
}
}
public static class TriangleData {
public final Vector3f tangent;
public final Vector3f binormal;
public final Vector3f normal;
@ -88,8 +90,7 @@ public class TangentBinormalGenerator {
public TriangleData(Vector3f tangent, Vector3f binormal,
Vector3f normal,
int index0, int index1, int index2)
{
int index0, int index1, int index2) {
this.tangent = tangent;
this.binormal = binormal;
this.normal = normal;
@ -112,13 +113,13 @@ public class TangentBinormalGenerator {
generate(mesh, true);
}
public static void generate(Spatial scene){
if (scene instanceof Node){
public static void generate(Spatial scene) {
if (scene instanceof Node) {
Node node = (Node) scene;
for (Spatial child : node.getChildren()){
for (Spatial child : node.getChildren()) {
generate(child);
}
}else{
} else {
Geometry geom = (Geometry) scene;
generate(geom.getMesh());
}
@ -133,33 +134,56 @@ public class TangentBinormalGenerator {
t[i] = new Vector2f();
}
if (mesh.getBuffer(Type.Normal) == null){
if (mesh.getBuffer(Type.Normal) == null) {
throw new IllegalArgumentException("The given mesh has no normal data!");
}
VertexData[] vertices;
switch (mesh.getMode()) {
case Triangles:
vertices = processTriangles(mesh, index, v, t); break;
vertices = processTriangles(mesh, index, v, t);
break;
case TriangleStrip:
vertices = processTriangleStrip(mesh, index, v, t); break;
vertices = processTriangleStrip(mesh, index, v, t);
break;
case TriangleFan:
vertices = processTriangleFan(mesh, index, v, t); break;
default: throw new UnsupportedOperationException(
vertices = processTriangleFan(mesh, index, v, t);
break;
default:
throw new UnsupportedOperationException(
mesh.getMode() + " is not supported.");
}
processTriangleData(mesh, vertices, approxTangents);
//if the mesh has a bind pose, we need to generate the bind pose for the tangent buffer
if (mesh.getBuffer(Type.BindPosePosition) != null) {
VertexBuffer tangents = mesh.getBuffer(Type.Tangent);
if (tangents != null) {
VertexBuffer bindTangents = new VertexBuffer(Type.BindPoseTangent);
bindTangents.setupData(Usage.CpuOnly,
4,
Format.Float,
BufferUtils.clone(tangents.getData()));
if (mesh.getBuffer(Type.BindPoseTangent) != null) {
mesh.clearBuffer(Type.BindPoseTangent);
}
mesh.setBuffer(bindTangents);
tangents.setUsage(Usage.Stream);
}
}
}
private static VertexData[] processTriangles(Mesh mesh,
int[] index, Vector3f[] v, Vector2f[] t)
{
int[] index, Vector3f[] v, Vector2f[] t) {
IndexBuffer indexBuffer = mesh.getIndexBuffer();
FloatBuffer vertexBuffer = (FloatBuffer) mesh.getBuffer(Type.Position).getData();
if (mesh.getBuffer(Type.TexCoord) == null)
if (mesh.getBuffer(Type.TexCoord) == null) {
throw new IllegalArgumentException("Can only generate tangents for "
+ "meshes with texture coordinates");
}
FloatBuffer textureBuffer = (FloatBuffer) mesh.getBuffer(Type.TexCoord).getData();
@ -167,7 +191,7 @@ public class TangentBinormalGenerator {
for (int i = 0; i < indexBuffer.size() / 3; i++) {
for (int j = 0; j < 3; j++) {
index[j] = indexBuffer.get(i*3 + j);
index[j] = indexBuffer.get(i * 3 + j);
populateFromBuffer(v[j], vertexBuffer, index[j]);
populateFromBuffer(t[j], textureBuffer, index[j]);
}
@ -182,9 +206,9 @@ public class TangentBinormalGenerator {
return vertices;
}
private static VertexData[] processTriangleStrip(Mesh mesh,
int[] index, Vector3f[] v, Vector2f[] t)
{
int[] index, Vector3f[] v, Vector2f[] t) {
IndexBuffer indexBuffer = mesh.getIndexBuffer();
FloatBuffer vertexBuffer = (FloatBuffer) mesh.getBuffer(Type.Position).getData();
FloatBuffer textureBuffer = (FloatBuffer) mesh.getBuffer(Type.TexCoord).getData();
@ -230,9 +254,9 @@ public class TangentBinormalGenerator {
return vertices;
}
private static VertexData[] processTriangleFan(Mesh mesh,
int[] index, Vector3f[] v, Vector2f[] t)
{
int[] index, Vector3f[] v, Vector2f[] t) {
IndexBuffer indexBuffer = mesh.getIndexBuffer();
FloatBuffer vertexBuffer = (FloatBuffer) mesh.getBuffer(Type.Position).getData();
FloatBuffer textureBuffer = (FloatBuffer) mesh.getBuffer(Type.TexCoord).getData();
@ -279,10 +303,8 @@ public class TangentBinormalGenerator {
return (a.subtract(b).cross(c.subtract(b))).lengthSquared() == 0;
}
public static TriangleData processTriangle(int[] index,
Vector3f[] v, Vector2f[] t)
{
Vector3f[] v, Vector2f[] t) {
Vector3f edge1 = new Vector3f();
Vector3f edge2 = new Vector3f();
Vector2f edge1uv = new Vector2f();
@ -294,15 +316,15 @@ public class TangentBinormalGenerator {
t[1].subtract(t[0], edge1uv);
t[2].subtract(t[0], edge2uv);
float det = edge1uv.x*edge2uv.y - edge1uv.y*edge2uv.x;
float det = edge1uv.x * edge2uv.y - edge1uv.y * edge2uv.x;
boolean normalize = false;
if (Math.abs(det) < ZERO_TOLERANCE) {
log.log(Level.WARNING, "Colinear uv coordinates for triangle " +
"[{0}, {1}, {2}]; tex0 = [{3}, {4}], " +
"tex1 = [{5}, {6}], tex2 = [{7}, {8}]",
new Object[]{ index[0], index[1], index[2],
t[0].x, t[0].y, t[1].x, t[1].y, t[2].x, t[2].y });
log.log(Level.WARNING, "Colinear uv coordinates for triangle "
+ "[{0}, {1}, {2}]; tex0 = [{3}, {4}], "
+ "tex1 = [{5}, {6}], tex2 = [{7}, {8}]",
new Object[]{index[0], index[1], index[2],
t[0].x, t[0].y, t[1].x, t[1].y, t[2].x, t[2].y});
det = 1;
normalize = true;
}
@ -316,23 +338,26 @@ public class TangentBinormalGenerator {
binormal.normalizeLocal();
if (Math.abs(Math.abs(tangent.dot(binormal)) - 1)
< ZERO_TOLERANCE)
{
log.log(Level.WARNING, "Vertices are on the same line " +
"for triangle [{0}, {1}, {2}].",
new Object[]{ index[0], index[1], index[2] });
< ZERO_TOLERANCE) {
log.log(Level.WARNING, "Vertices are on the same line "
+ "for triangle [{0}, {1}, {2}].",
new Object[]{index[0], index[1], index[2]});
}
float factor = 1/det;
tangent.x = (edge2uv.y*edge1.x - edge1uv.y*edge2.x)*factor;
tangent.y = (edge2uv.y*edge1.y - edge1uv.y*edge2.y)*factor;
tangent.z = (edge2uv.y*edge1.z - edge1uv.y*edge2.z)*factor;
if (normalize) tangent.normalizeLocal();
float factor = 1 / det;
tangent.x = (edge2uv.y * edge1.x - edge1uv.y * edge2.x) * factor;
tangent.y = (edge2uv.y * edge1.y - edge1uv.y * edge2.y) * factor;
tangent.z = (edge2uv.y * edge1.z - edge1uv.y * edge2.z) * factor;
if (normalize) {
tangent.normalizeLocal();
}
binormal.x = (edge1uv.x*edge2.x - edge2uv.x*edge1.x)*factor;
binormal.y = (edge1uv.x*edge2.y - edge2uv.x*edge1.y)*factor;
binormal.z = (edge1uv.x*edge2.z - edge2uv.x*edge1.z)*factor;
if (normalize) binormal.normalizeLocal();
binormal.x = (edge1uv.x * edge2.x - edge2uv.x * edge1.x) * factor;
binormal.y = (edge1uv.x * edge2.y - edge2uv.x * edge1.y) * factor;
binormal.z = (edge1uv.x * edge2.z - edge2uv.x * edge1.z) * factor;
if (normalize) {
binormal.normalizeLocal();
}
tangent.cross(binormal, normal);
normal.normalizeLocal();
@ -341,8 +366,7 @@ public class TangentBinormalGenerator {
tangent,
binormal,
normal,
index[0], index[1], index[2]
);
index[0], index[1], index[2]);
}
public static void setToleranceAngle(float angle) {
@ -350,13 +374,12 @@ public class TangentBinormalGenerator {
throw new IllegalArgumentException(
"The angle must be between 0 and 179 degrees.");
}
toleranceDot = FastMath.cos(angle*FastMath.DEG_TO_RAD);
toleranceDot = FastMath.cos(angle * FastMath.DEG_TO_RAD);
toleranceAngle = angle;
}
private static void processTriangleData(Mesh mesh, VertexData[] vertices,
boolean approxTangent)
{
boolean approxTangent) {
FloatBuffer normalBuffer = (FloatBuffer) mesh.getBuffer(Type.Normal).getData();
FloatBuffer tangents = BufferUtils.createFloatBuffer(vertices.length * 4);
@ -392,8 +415,8 @@ public class TangentBinormalGenerator {
tangentUnit.normalizeLocal();
if (tangent.dot(tangentUnit) < toleranceDot) {
log.log(Level.WARNING,
"Angle between tangents exceeds tolerance " +
"for vertex {0}.", i);
"Angle between tangents exceeds tolerance "
+ "for vertex {0}.", i);
break;
}
@ -402,8 +425,8 @@ public class TangentBinormalGenerator {
binormalUnit.normalizeLocal();
if (binormal.dot(binormalUnit) < toleranceDot) {
log.log(Level.WARNING,
"Angle between binormals exceeds tolerance " +
"for vertex {0}.", i);
"Angle between binormals exceeds tolerance "
+ "for vertex {0}.", i);
break;
}
}
@ -439,21 +462,18 @@ public class TangentBinormalGenerator {
if (binormal.length() >= ZERO_TOLERANCE) {
binormal.cross(givenNormal, tangent);
tangent.normalizeLocal();
}
// if all fails use the tangent from the first triangle
} // if all fails use the tangent from the first triangle
else {
tangent.set(triangles.get(0).tangent);
}
}
else {
} else {
tangent.divideLocal(triangles.size());
}
tangentUnit.set(tangent);
tangentUnit.normalizeLocal();
if (Math.abs(Math.abs(tangentUnit.dot(givenNormal)) - 1)
< ZERO_TOLERANCE)
{
< ZERO_TOLERANCE) {
log.log(Level.WARNING,
"Normal and tangent are parallel for vertex {0}.", i);
}
@ -467,28 +487,24 @@ public class TangentBinormalGenerator {
if (tangent.length() >= ZERO_TOLERANCE) {
givenNormal.cross(tangent, binormal);
binormal.normalizeLocal();
}
// if all fails use the binormal from the first triangle
} // if all fails use the binormal from the first triangle
else {
binormal.set(triangles.get(0).binormal);
}
}
else {
} else {
binormal.divideLocal(triangles.size());
}
binormalUnit.set(binormal);
binormalUnit.normalizeLocal();
if (Math.abs(Math.abs(binormalUnit.dot(givenNormal)) - 1)
< ZERO_TOLERANCE)
{
< ZERO_TOLERANCE) {
log.log(Level.WARNING,
"Normal and binormal are parallel for vertex {0}.", i);
}
if (Math.abs(Math.abs(binormalUnit.dot(tangentUnit)) - 1)
< ZERO_TOLERANCE)
{
< ZERO_TOLERANCE) {
log.log(Level.WARNING,
"Tangent and binormal are parallel for vertex {0}.", i);
}
@ -503,8 +519,7 @@ public class TangentBinormalGenerator {
tangents.put((i * 4) + 1, tangent.y);
tangents.put((i * 4) + 2, tangent.z);
tangents.put((i * 4) + 3, wCoord);
}
else {
} else {
tangents.put((i * 4), tangent.x);
tangents.put((i * 4) + 1, tangent.y);
tangents.put((i * 4) + 2, tangent.z);
@ -519,11 +534,12 @@ public class TangentBinormalGenerator {
}
public static Mesh genTbnLines(Mesh mesh, float scale) {
if (mesh.getBuffer(Type.Tangent) == null)
if (mesh.getBuffer(Type.Tangent) == null) {
return genNormalLines(mesh, scale);
else
} else {
return genTangentLines(mesh, scale);
}
}
public static Mesh genNormalLines(Mesh mesh, float scale) {
FloatBuffer vertexBuffer = (FloatBuffer) mesh.getBuffer(Type.Position).getData();
@ -598,12 +614,12 @@ public class TangentBinormalGenerator {
populateFromBuffer(origin, vertexBuffer, i);
populateFromBuffer(normal, normalBuffer, i);
if (hasParity){
if (hasParity) {
tangent.x = tangentBuffer.get(i * 4);
tangent.y = tangentBuffer.get(i * 4 + 1);
tangent.z = tangentBuffer.get(i * 4 + 2);
tangentW = tangentBuffer.get(i * 4 + 3);
}else{
} else {
populateFromBuffer(tangent, tangentBuffer, i);
}

2
engine/src/core/com/jme3/util/TempVars.java

@ -157,6 +157,8 @@ public class TempVars {
*/
public final float[] skinPositions = new float[512 * 3];
public final float[] skinNormals = new float[512 * 3];
//tangent buffer as 4 components by elements
public final float[] skinTangents = new float[512 * 4];
/**
* Fetching triangle from mesh
*/