- TangentBinormalGenerator now splits vertices with mirrored uvs. This is an optional operation.

It fixes the issue in this thread : http://hub.jmonkeyengine.org/forum/topic/normalmapslighting-issue/
Next step is to split vertices that have triangles with heavily rotated tangent spaces.

git-svn-id: https://jmonkeyengine.googlecode.com/svn/trunk@10698 75d07b2b-3a1a-0410-a2c5-0572b91ccdca

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

@@ -35,16 +35,22 @@ import com.jme3.math.ColorRGBA;
 import com.jme3.math.FastMath;
 import com.jme3.math.Vector2f;
 import com.jme3.math.Vector3f;
-import com.jme3.math.Vector4f;
 import com.jme3.scene.*;
 import com.jme3.scene.VertexBuffer.Format;
 import com.jme3.scene.VertexBuffer.Type;
 import com.jme3.scene.VertexBuffer.Usage;
 import com.jme3.scene.mesh.IndexBuffer;
 import static com.jme3.util.BufferUtils.*;
+import java.nio.Buffer;
+import java.nio.ByteBuffer;
+import java.nio.DoubleBuffer;
 import java.nio.FloatBuffer;
 import java.nio.IntBuffer;
+import java.nio.ShortBuffer;
 import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
@@ -57,8 +63,8 @@ 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;
+    public static boolean debug = false;
     
     static {
         setToleranceAngle(45);
@@ -92,31 +98,38 @@ public class TangentBinormalGenerator {
         public final Vector3f tangent;
         public final Vector3f binormal;
         public final Vector3f normal;        
+        public int[] index = new int[3];
+        public int triangleOffset;
         
         public TriangleData(Vector3f tangent, Vector3f binormal, Vector3f normal) {
             this.tangent = tangent;
             this.binormal = binormal;
             this.normal = normal;
         }
+        public void setIndex(int[] index) {
+            for (int i = 0; i < index.length; i++) {
+                this.index[i] = index[i];
+            }
+        }
     }
     
-    private static VertexData[] initVertexData(int size) {
+    private static List<VertexData> initVertexData(int size) {
-        VertexData[] vertices = new VertexData[size];
+        List<VertexData> vertices = new ArrayList<VertexData>(size);        
         for (int i = 0; i < size; i++) {
-            vertices[i] = new VertexData();
+            vertices.add(new VertexData());
         }
         return vertices;
     }
     
     public static void generate(Mesh mesh) {
-        generate(mesh, true);
+        generate(mesh, true, false);
     }
     
-    public static void generate(Spatial scene) {
+    public static void generate(Spatial scene, boolean splitMirrored) {
         if (scene instanceof Node) {
             Node node = (Node) scene;
             for (Spatial child : node.getChildren()) {
-                generate(child);
+                generate(child, splitMirrored);
             }
         } else {
             Geometry geom = (Geometry) scene;
@@ -125,12 +138,16 @@ public class TangentBinormalGenerator {
             // Check to ensure mesh has texcoords and normals before generating
             if (mesh.getBuffer(Type.TexCoord) != null 
              && mesh.getBuffer(Type.Normal) != null){
-                generate(geom.getMesh());
+                generate(geom.getMesh(),true, splitMirrored);
             }
         }
     }
     
-    public static void generate(Mesh mesh, boolean approxTangents) {
+    public static void generate(Spatial scene) {
+        generate(scene, false);
+    }
+    
+    public static void generate(Mesh mesh, boolean approxTangents, boolean splitMirrored) {        
         int[] index = new int[3];
         Vector3f[] v = new Vector3f[3];
         Vector2f[] t = new Vector2f[3];
@@ -143,10 +160,13 @@ public class TangentBinormalGenerator {
             throw new IllegalArgumentException("The given mesh has no normal data!");
         }
         
-        VertexData[] vertices;
+         List<VertexData> vertices;
         switch (mesh.getMode()) {
             case Triangles:
-                vertices = processTriangles(mesh, index, v, t);
+                vertices = processTriangles(mesh, index, v, t, splitMirrored);
+                if(splitMirrored){
+                    splitVertices(mesh, vertices, splitMirrored);
+                }
                 break;
             case TriangleStrip:
                 vertices = processTriangleStrip(mesh, index, v, t);
@@ -181,8 +201,8 @@ public class TangentBinormalGenerator {
         }
     }
     
-    private static VertexData[] processTriangles(Mesh mesh,
+    private static  List<VertexData> processTriangles(Mesh mesh,
-            int[] index, Vector3f[] v, Vector2f[] t) {
+            int[] index, Vector3f[] v, Vector2f[] t, boolean splitMirrored) {
         IndexBuffer indexBuffer = mesh.getIndexBuffer();
         FloatBuffer vertexBuffer = (FloatBuffer) mesh.getBuffer(Type.Position).getData();
         if (mesh.getBuffer(Type.TexCoord) == null) {
@@ -192,7 +212,7 @@ public class TangentBinormalGenerator {
         
         FloatBuffer textureBuffer = (FloatBuffer) mesh.getBuffer(Type.TexCoord).getData();
         
-        VertexData[] vertices = initVertexData(vertexBuffer.limit() / 3);
+        List<VertexData> vertices = initVertexData(vertexBuffer.limit() / 3);
         
         for (int i = 0; i < indexBuffer.size() / 3; i++) {
             for (int j = 0; j < 3; j++) {
@@ -202,23 +222,201 @@ public class TangentBinormalGenerator {
             }
             
             TriangleData triData = processTriangle(index, v, t);
+            if(splitMirrored){
+                triData.setIndex(index);
+                triData.triangleOffset = i * 3 ;
+            }
             if (triData != null) {
-                vertices[index[0]].triangles.add(triData);
+                vertices.get(index[0]).triangles.add(triData);
-                vertices[index[1]].triangles.add(triData);
+                vertices.get(index[1]).triangles.add(triData);
-                vertices[index[2]].triangles.add(triData);
+                vertices.get(index[2]).triangles.add(triData);
             }
         }
         
         return vertices;
     }
     
-    private static VertexData[] processTriangleStrip(Mesh mesh,
+    //Don't remove splitmirorred boolean,It's not used right now, but i intend to
+    //make this method also split vertice with rotated tangent space and I'll
+    //add another splitRotated boolean 
+    private static List<VertexData> splitVertices(Mesh mesh, List<VertexData> vertexData, boolean splitMirorred) {
+        int nbVertices = mesh.getBuffer(Type.Position).getNumElements();
+        List<VertexData> newVertices = new ArrayList<VertexData>();
+        Map<Integer, Integer> indiceMap = new HashMap<Integer, Integer>();
+        FloatBuffer normalBuffer = mesh.getFloatBuffer(Type.Normal);
+
+        for (int i = 0; i < vertexData.size(); i++) {
+            ArrayList<TriangleData> triangles = vertexData.get(i).triangles;
+            Vector3f givenNormal = new Vector3f();
+            populateFromBuffer(givenNormal, normalBuffer, i);
+          
+            ArrayList<TriangleData> trianglesUp = new ArrayList<TriangleData>();
+            ArrayList<TriangleData> trianglesDown = new ArrayList<TriangleData>();  
+            for (int j = 0; j < triangles.size(); j++) {
+                TriangleData triangleData = triangles.get(j);
+                if(parity(givenNormal, triangleData.normal) > 0){
+                    trianglesUp.add(triangleData);
+                }else{
+                    trianglesDown.add(triangleData);
+                }
+            }
+            
+            //if the vertex has triangles with opposite parity it has to be split
+            if(!trianglesUp.isEmpty() && !trianglesDown.isEmpty()){
+                log.log(Level.FINE, "Splitting vertex {0}", i);
+                //assigning triangle with the same parity to the original vertex
+                vertexData.get(i).triangles.clear();
+                vertexData.get(i).triangles.addAll(trianglesUp);
+                
+                //creating a new vertex
+                VertexData newVert = new VertexData();
+                //assigning triangles with opposite parity to it
+                newVert.triangles.addAll(trianglesDown);
+                
+                newVertices.add(newVert);
+                //keep vertex index to fix the index buffers later
+                indiceMap.put(nbVertices, i);
+                for (TriangleData tri : newVert.triangles) {
+                    for (int j = 0; j < tri.index.length; j++) {
+                        if(tri.index[j] == i){
+                            tri.index[j] = nbVertices;                            
+                        }
+                    }
+                }
+                nbVertices++;
+                
+            }            
+
+
+        }
+
+        if(!newVertices.isEmpty()){
+            
+            //we have new vertices, we need to update the mesh's buffers.
+            for (Type type : VertexBuffer.Type.values()) {
+                //skip tangent buffer as we're gonna overwrite it later
+                if(type == Type.Tangent || type == Type.BindPoseTangent) continue;
+                VertexBuffer vb = mesh.getBuffer(type);
+                //Some buffer (hardware skinning ones) can be there but not 
+                //initialized, they must be skipped. 
+                //They'll be initialized when Hardware Skinning is engaged
+                if(vb==null || vb.getNumComponents() == 0) continue;
+                
+                Buffer buffer = vb.getData();   
+                //IndexBuffer has special treatement, only swapping the vertex indices is needed                
+                if(type == Type.Index){
+                    boolean isShortBuffer = vb.getFormat() == VertexBuffer.Format.UnsignedShort;                     
+                    for (VertexData vertex : newVertices) {
+                        for (TriangleData tri : vertex.triangles) {
+                            for (int i = 0; i < tri.index.length; i++) {
+                                if (isShortBuffer) {
+                                    ((ShortBuffer) buffer).put(tri.triangleOffset + i, (short) tri.index[i]);
+                                } else {
+                                    ((IntBuffer) buffer).put(tri.triangleOffset + i, tri.index[i]);
+                                }
+                            }
+                        }
+                    }
+                    vb.setUpdateNeeded();
+                }else{
+                    //copy the buffer in a bigger one and append nex vertices to the end
+                    Buffer newVerts = VertexBuffer.createBuffer(vb.getFormat(), vb.getNumComponents(), nbVertices);                   
+                    if (buffer != null) {
+                        buffer.rewind();
+                        bulkPut(vb.getFormat(), newVerts,buffer);  
+                        
+                        int index = vertexData.size();                      
+                        newVerts.position(vertexData.size() * vb.getNumComponents());
+                        for (int j = 0; j < newVertices.size(); j++) {
+                            int oldInd = indiceMap.get(index) ;
+                            for (int i = 0; i < vb.getNumComponents(); i++) {                                
+                                    putValue(vb.getFormat(), newVerts, buffer, oldInd* vb.getNumComponents() + i);
+                            }                            
+                            index++;
+                        }                        
+                        vb.updateData(newVerts);    
+                        //destroy previous buffer as it's no longer needed
+                        destroyDirectBuffer(buffer);
+                    }             
+                }                
+            }
+            vertexData.addAll(newVertices);
+            
+            mesh.updateCounts();
+        }
+
+        return vertexData;
+    }
+    
+    private static void bulkPut(VertexBuffer.Format format, Buffer buf1, Buffer buf2) {
+        switch (format) {
+            case Byte:
+            case Half:
+            case UnsignedByte:
+                ((ByteBuffer) buf1).put((ByteBuffer) buf2);
+                break;
+            case Short:
+            case UnsignedShort:
+
+                ((ShortBuffer) buf1).put((ShortBuffer) buf2);
+                break;
+
+            case Int:
+            case UnsignedInt:
+                ((IntBuffer) buf1).put((IntBuffer) buf2);
+                break;
+            case Float:
+
+                ((FloatBuffer) buf1).put((FloatBuffer) buf2);
+                break;
+            case Double:
+                ((DoubleBuffer) buf1).put((DoubleBuffer) buf2);
+                break;
+
+            default:
+                throw new UnsupportedOperationException("Unrecoginized buffer format: " + format);
+        }
+    }
+    
+     private static void putValue(VertexBuffer.Format format, Buffer buf1, Buffer buf2,int index) {
+        switch (format) {
+            case Byte:
+            case Half:
+            case UnsignedByte:
+                byte b = ((ByteBuffer) buf2).get(index);
+                ((ByteBuffer) buf1).put(b);
+                break;
+            case Short:
+            case UnsignedShort:
+                short s = ((ShortBuffer) buf2).get(index);
+                ((ShortBuffer) buf1).put(s);              
+                break;
+
+            case Int:
+            case UnsignedInt:
+                int i = ((IntBuffer) buf2).get(index);
+                ((IntBuffer) buf1).put(i);              
+                break;                
+            case Float:
+                float f = ((FloatBuffer) buf2).get(index);
+                ((FloatBuffer) buf1).put(f);              
+                break;                   
+            case Double:
+                double d = ((DoubleBuffer) buf2).get(index);
+                ((DoubleBuffer) buf1).put(d);              
+                break;                 
+            default:
+                throw new UnsupportedOperationException("Unrecoginized buffer format: " + format);
+        }
+    }
+    
+    private static List<VertexData> processTriangleStrip(Mesh mesh,
             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();
         
-        VertexData[] vertices = initVertexData(vertexBuffer.limit() / 3);
+        List<VertexData> vertices = initVertexData(vertexBuffer.limit() / 3);
         
         index[0] = indexBuffer.get(0);
         index[1] = indexBuffer.get(1);
@@ -238,9 +436,9 @@ public class TangentBinormalGenerator {
             TriangleData triData = processTriangle(index, v, t);
             
             if (triData != null && !isDegenerate) {
-                vertices[index[0]].triangles.add(triData);
+                vertices.get(index[0]).triangles.add(triData);
-                vertices[index[1]].triangles.add(triData);
+                vertices.get(index[1]).triangles.add(triData);
-                vertices[index[2]].triangles.add(triData);
+                vertices.get(index[2]).triangles.add(triData);
             }
             
             Vector3f vTemp = v[0];
@@ -260,13 +458,13 @@ public class TangentBinormalGenerator {
         return vertices;
     }
     
-    private static VertexData[] processTriangleFan(Mesh mesh,
+    private static List<VertexData> processTriangleFan(Mesh mesh,
             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();
         
-        VertexData[] vertices = initVertexData(vertexBuffer.limit() / 3);
+        List<VertexData> vertices = initVertexData(vertexBuffer.limit() / 3);
         
         index[0] = indexBuffer.get(0);
         index[1] = indexBuffer.get(1);
@@ -284,9 +482,9 @@ public class TangentBinormalGenerator {
             
             TriangleData triData = processTriangle(index, v, t);
             if (triData != null) {
-                vertices[index[0]].triangles.add(triData);
+                vertices.get(index[0]).triangles.add(triData);
-                vertices[index[1]].triangles.add(triData);
+                vertices.get(index[1]).triangles.add(triData);
-                vertices[index[2]].triangles.add(triData);
+                vertices.get(index[2]).triangles.add(triData);
             }
             
             Vector3f vTemp = v[1];
@@ -379,7 +577,6 @@ public class TangentBinormalGenerator {
                     "The angle must be between 0 and 179 degrees.");
         }
         toleranceDot = FastMath.cos(angle * FastMath.DEG_TO_RAD);
-        toleranceAngle = angle;
     }
     
     
@@ -415,18 +612,20 @@ public class TangentBinormalGenerator {
             populateFromBuffer(texCoord, texcoordBuffer, i);
             
             boolean found = false;
-            
+            //Nehon 07/07/2013
-            for (int j = 0; j < vertexMap.size(); j++) {
+            //Removed this part, joining splitted vertice to compute tangent space makes no sense to me
-                VertexInfo vertexInfo = vertexMap.get(j);
+            //separate vertice should have separate tangent space            
-                if (approxEqual(vertexInfo.position, position) &&
+//            for (int j = 0; j < vertexMap.size(); j++) {
-                    approxEqual(vertexInfo.normal, normal) &&
+//                VertexInfo vertexInfo = vertexMap.get(j);
-                    approxEqual(vertexInfo.texCoord, texCoord))
+//                if (approxEqual(vertexInfo.position, position) &&
-                {
+//                    approxEqual(vertexInfo.normal, normal) &&
-                    vertexInfo.indices.add(i);
+//                    approxEqual(vertexInfo.texCoord, texCoord))
-                    found = true;
+//                {
-                    break;  
+//                    vertexInfo.indices.add(i);
-                }
+//                    found = true;
-            }
+//                    break;  
+//                }
+//            }
             
             if (!found) {
                 VertexInfo vertexInfo = new VertexInfo(position.clone(), normal.clone(), texCoord.clone());
@@ -438,15 +637,16 @@ public class TangentBinormalGenerator {
         return vertexMap;
     }
     
-    private static void processTriangleData(Mesh mesh, VertexData[] vertices,
+    private static void processTriangleData(Mesh mesh, List<VertexData> vertices,
-            boolean approxTangent)
+            boolean approxTangent) {
-    {
         ArrayList<VertexInfo> vertexMap = linkVertices(mesh);
 
-       // FloatBuffer normalBuffer = (FloatBuffer) mesh.getBuffer(Type.Normal).getData();
+        FloatBuffer tangents = BufferUtils.createFloatBuffer(vertices.size() * 4);
 
-        FloatBuffer tangents = BufferUtils.createFloatBuffer(vertices.length * 4);
+        ColorRGBA[] cols = null;
-//        FloatBuffer binormals = BufferUtils.createFloatBuffer(vertices.length * 3);
+        if (debug) {
+            cols = new ColorRGBA[vertices.size()];
+        }
 
         Vector3f tangent = new Vector3f();
         Vector3f binormal = new Vector3f();
@@ -464,7 +664,7 @@ public class TangentBinormalGenerator {
             givenNormal.set(vertexInfo.normal);
             givenNormal.normalizeLocal();
 
-            TriangleData firstTriangle = vertices[vertexInfo.indices.get(0)].triangles.get(0);
+            TriangleData firstTriangle = vertices.get(vertexInfo.indices.get(0)).triangles.get(0);
 
             // check tangent and binormal consistency
             tangent.set(firstTriangle.tangent);
@@ -473,7 +673,7 @@ public class TangentBinormalGenerator {
             binormal.normalizeLocal();
 
             for (int i : vertexInfo.indices) {
-                ArrayList<TriangleData> triangles = vertices[i].triangles;
+                ArrayList<TriangleData> triangles = vertices.get(i).triangles;
 
                 for (int j = 0; j < triangles.size(); j++) {
                     TriangleData triangleData = triangles.get(j);
@@ -507,27 +707,18 @@ public class TangentBinormalGenerator {
 
             int triangleCount = 0;
             for (int i : vertexInfo.indices) {
-                ArrayList<TriangleData> triangles = vertices[i].triangles;
+                ArrayList<TriangleData> triangles = vertices.get(i).triangles;
                 triangleCount += triangles.size();
+                if (debug) {
+                    cols[i] = ColorRGBA.White;
+                }
 
-          //      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 (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;
-//                }
             }
 
 
@@ -596,7 +787,7 @@ public class TangentBinormalGenerator {
                     finalTangent.set(tangent).subtractLocal(tmp.set(givenNormal).multLocal(givenNormal.dot(tangent)));
                     finalTangent.normalizeLocal();
 
-                    wCoord = tmp.set(givenNormal).crossLocal(tangent).dot(binormal) <0f? -1f:1f;
+                    wCoord = tmp.set(givenNormal).crossLocal(tangent).dot(binormal) < 0f ? -1f : 1f;
 
                     tangents.put((i * 4), finalTangent.x);
                     tangents.put((i * 4) + 1, finalTangent.y);
@@ -612,11 +803,47 @@ public class TangentBinormalGenerator {
                 }
             }
         }
-        
+        tangents.limit(tangents.capacity());
         // If the model already had a tangent buffer, replace it with the regenerated one
         mesh.clearBuffer(Type.Tangent);
         mesh.setBuffer(Type.Tangent, 4, tangents);
-//        if (!approxTangent) mesh.setBuffer(Type.Binormal, 3, binormals);
+        
+        
+        
+        if(mesh.isAnimated()){
+            mesh.clearBuffer(Type.BindPoseNormal);
+            mesh.clearBuffer(Type.BindPosePosition);
+            mesh.clearBuffer(Type.BindPoseTangent);
+            mesh.generateBindPose(true);
+        }
+
+        if (debug) {
+            writeColorBuffer( vertices, cols, mesh);
+        }
+        mesh.updateBound();
+        mesh.updateCounts();
+    }    
+    
+    private static void writeColorBuffer(List<VertexData> vertices, ColorRGBA[] cols, Mesh mesh) {
+        FloatBuffer colors = BufferUtils.createFloatBuffer(vertices.size() * 4);
+        colors.rewind();
+        for (ColorRGBA color : cols) {
+            colors.put(color.r);
+            colors.put(color.g);
+            colors.put(color.b);
+            colors.put(color.a);
+        }
+        mesh.clearBuffer(Type.Color);
+        mesh.setBuffer(Type.Color, 4, colors);
+    }
+
+    private static int parity(Vector3f n1, Vector3f n) {
+        if (n1.dot(n) < 0) {
+            return -1;
+        } else {
+            return 1;
+        }
+
     }
 
     public static Mesh genTbnLines(Mesh mesh, float scale) {