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
3.0
rem..om 13 years ago
parent 40e32790d6
commit a5ff915fc1
5 changed files with 425 additions and 211 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. 226
      engine/src/core/com/jme3/animation/SkeletonControl.java
  2. 11
      engine/src/core/com/jme3/scene/Mesh.java
  3. 13
      engine/src/core/com/jme3/scene/VertexBuffer.java
  4. 192
      engine/src/core/com/jme3/util/TangentBinormalGenerator.java
  5. 2
      engine/src/core/com/jme3/util/TempVars.java

226
engine/src/core/com/jme3/animation/SkeletonControl.java
Unescape View File

@ -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;
}
}
@ -145,11 +145,11 @@ public class SkeletonControl extends AbstractControl implements Cloneable {
// if hardware skinning is supported, the matrices and weight buffer
// will be sent by the SkinningShaderLogic object assigned to the shader
for (int i = 0; i < targets.length; i++) {
// NOTE: This assumes that code higher up
// Already ensured those targets are animated
// otherwise a crash will happen in skin update
// NOTE: This assumes that code higher up
// Already ensured those targets are animated
// otherwise a crash will happen in skin update
//if (isMeshAnimated(targets[i])) {
softwareSkinUpdate(targets[i], offsetMatrices);
softwareSkinUpdate(targets[i], offsetMatrices);
//}
}
@ -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();
}
@ -195,10 +208,10 @@ public class SkeletonControl extends AbstractControl implements Cloneable {
clone.setSpatial(clonedNode);
clone.skeleton = ctrl.getSkeleton();
// Fix animated targets for the cloned node
// Fix animated targets for the cloned node
clone.targets = findTargets(clonedNode);
// Fix attachments for the cloned node
// Fix attachments for the cloned node
for (int i = 0; i < clonedNode.getQuantity(); i++) {
// go through attachment nodes, apply them to correct bone
Spatial child = clonedNode.getChild(i);
@ -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
Unescape View File

@ -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
Unescape View File

@ -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

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

@ -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;
@ -58,8 +60,7 @@ public class TangentBinormalGenerator {
private static final float ZERO_TOLERANCE = 0.0000001f;
private static final Logger log = Logger.getLogger(
TangentBinormalGenerator.class.getName());
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>();
new ArrayList<TriangleData>();
public VertexData() {
}
}
public static class TriangleData {
public final Vector3f tangent;
public final Vector3f binormal;
public final Vector3f normal;
@ -87,9 +89,8 @@ public class TangentBinormalGenerator {
public int index2;
public TriangleData(Vector3f tangent, Vector3f binormal,
Vector3f normal,
int index0, int index1, int index2)
{
Vector3f normal,
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(
mesh.getMode() + " is not supported.");
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)
{
IndexBuffer indexBuffer = mesh.getIndexBuffer();
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");
+ "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,10 +206,10 @@ public class TangentBinormalGenerator {
return vertices;
}
private static VertexData[] processTriangleStrip(Mesh mesh,
int[] index, Vector3f[] v, Vector2f[] t)
{
IndexBuffer indexBuffer = mesh.getIndexBuffer();
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,10 +254,10 @@ public class TangentBinormalGenerator {
return vertices;
}
private static VertexData[] processTriangleFan(Mesh mesh,
int[] index, Vector3f[] v, Vector2f[] t)
{
IndexBuffer indexBuffer = mesh.getIndexBuffer();
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,47 +338,48 @@ 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();
return new TriangleData(
tangent,
binormal,
normal,
index[0], index[1], index[2]
);
tangent,
binormal,
normal,
index[0], index[1], index[2]);
}
public static void setToleranceAngle(float angle) {
if (angle < 0 || angle > 179) {
throw new IllegalArgumentException(
"The angle must be between 0 and 179 degrees.");
"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);
@ -514,15 +529,16 @@ public class TangentBinormalGenerator {
}
}
mesh.setBuffer(Type.Tangent, 4, tangents);
mesh.setBuffer(Type.Tangent, 4, tangents);
// if (!approxTangent) mesh.setBuffer(Type.Binormal, 3, binormals);
}
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) {
@ -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{
tangentW = tangentBuffer.get(i * 4 + 3);
} else {
populateFromBuffer(tangent, tangentBuffer, i);
}

2
engine/src/core/com/jme3/util/TempVars.java
Unescape View File

@ -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
*/

Write Preview
Loading…
Cancel
Save