Use TempVars for triangle processing instead of explicit allocations, speeds up processing by around 30%

jme3-core/src/main/java/com/jme3/util/TangentBinormalGenerator.java

@@ -556,67 +556,72 @@ public class TangentBinormalGenerator {
     
     public static TriangleData processTriangle(int[] index,
             Vector3f[] v, Vector2f[] t) {
-        Vector3f edge1 = new Vector3f();
+    	TempVars tmp = TempVars.get();
-        Vector3f edge2 = new Vector3f();
+    	try {
-        Vector2f edge1uv = new Vector2f();
+	        Vector3f edge1 = tmp.vect1;
-        Vector2f edge2uv = new Vector2f();
+	        Vector3f edge2 = tmp.vect2;
-        
+	        Vector2f edge1uv = tmp.vect2d;
-        Vector3f tangent = new Vector3f();
+	        Vector2f edge2uv = tmp.vect2d2;
-        Vector3f binormal = new Vector3f();
+	        
-        Vector3f normal = new Vector3f();
+	        Vector3f tangent = tmp.vect3;
-        
+	        Vector3f binormal = tmp.vect4;
-        t[1].subtract(t[0], edge1uv);
+	        Vector3f normal = tmp.vect5;
-        t[2].subtract(t[0], edge2uv);
+	        
-        float det = edge1uv.x * edge2uv.y - edge1uv.y * edge2uv.x;
+	        t[1].subtract(t[0], edge1uv);
-        
+	        t[2].subtract(t[0], edge2uv);
-        boolean normalize = false;
+	        float det = edge1uv.x * edge2uv.y - edge1uv.y * edge2uv.x;
-        if (Math.abs(det) < ZERO_TOLERANCE) {
+	        
-            log.log(Level.WARNING, "Colinear uv coordinates for triangle "
+	        boolean normalize = false;
-                    + "[{0}, {1}, {2}]; tex0 = [{3}, {4}], "
+	        if (Math.abs(det) < ZERO_TOLERANCE) {
-                    + "tex1 = [{5}, {6}], tex2 = [{7}, {8}]",
+	            log.log(Level.WARNING, "Colinear uv coordinates for triangle "
-                    new Object[]{index[0], index[1], index[2],
+	                    + "[{0}, {1}, {2}]; tex0 = [{3}, {4}], "
-                        t[0].x, t[0].y, t[1].x, t[1].y, t[2].x, t[2].y});
+	                    + "tex1 = [{5}, {6}], tex2 = [{7}, {8}]",
-            det = 1;
+	                    new Object[]{index[0], index[1], index[2],
-            normalize = true;
+	                        t[0].x, t[0].y, t[1].x, t[1].y, t[2].x, t[2].y});
-        }
+	            det = 1;
-        
+	            normalize = true;
-        v[1].subtract(v[0], edge1);
+	        }
-        v[2].subtract(v[0], edge2);
+	        
-        
+	        v[1].subtract(v[0], edge1);
-        tangent.set(edge1);
+	        v[2].subtract(v[0], edge2);
-        tangent.normalizeLocal();
+	        
-        binormal.set(edge2);
+	        tangent.set(edge1);
-        binormal.normalizeLocal();
+	        tangent.normalizeLocal();
-        
+	        binormal.set(edge2);
-        if (Math.abs(Math.abs(tangent.dot(binormal)) - 1)
+	        binormal.normalizeLocal();
-                < ZERO_TOLERANCE) {
+	        
-            log.log(Level.WARNING, "Vertices are on the same line "
+	        if (Math.abs(Math.abs(tangent.dot(binormal)) - 1)
-                    + "for triangle [{0}, {1}, {2}].",
+	                < ZERO_TOLERANCE) {
-                    new Object[]{index[0], index[1], index[2]});
+	            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;
+	        float factor = 1 / det;
-        tangent.z = (edge2uv.y * edge1.z - edge1uv.y * edge2.z) * factor;
+	        tangent.x = (edge2uv.y * edge1.x - edge1uv.y * edge2.x) * factor;
-        if (normalize) {
+	        tangent.y = (edge2uv.y * edge1.y - edge1uv.y * edge2.y) * factor;
-            tangent.normalizeLocal();
+	        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;
+	        binormal.x = (edge1uv.x * edge2.x - edge2uv.x * edge1.x) * factor;
-        if (normalize) {
+	        binormal.y = (edge1uv.x * edge2.y - edge2uv.x * edge1.y) * factor;
-            binormal.normalizeLocal();
+	        binormal.z = (edge1uv.x * edge2.z - edge2uv.x * edge1.z) * factor;
-        }
+	        if (normalize) {
-        
+	            binormal.normalizeLocal();
-        tangent.cross(binormal, normal);
+	        }
-        normal.normalizeLocal();
+	        
-        
+	        tangent.cross(binormal, normal);
-        return new TriangleData(
+	        normal.normalizeLocal();
-                tangent,
+	        
-                binormal,
+	        return new TriangleData(
-                normal);
+	                tangent,
+	                binormal,
+	                normal);
+    	} finally {
+    		tmp.release();
+    	}
     }
     
     public static void setToleranceAngle(float angle) {