CompositeMesh corrections for collisions/cloth

Here are some bugfixes, which should make cloth demo working with CompositeSphere.


Index: CollidingClothPatch.java
===================================================================
RCS file: /cvs/jme/src/com/jme/effects/cloth/CollidingClothPatch.java,v
retrieving revision 1.1
diff -u -r1.1 CollidingClothPatch.java
--- CollidingClothPatch.java   29 Nov 2004 21:24:55 -0000   1.1
+++ CollidingClothPatch.java   11 Dec 2004 15:02:20 -0000
@@ -120,9 +120,9 @@
       srcTemps[1] = system.getNode(indices[srcTriIndex * 3 + 1]);
       srcTemps[2] = system.getNode(indices[srcTriIndex * 3 + 2]);
 
-      tgtTemps[0] = target.getVertices()[target.getIndices()[tgtTriIndex * 3 + 0]];
-      tgtTemps[1] = target.getVertices()[target.getIndices()[tgtTriIndex * 3 + 1]];
-      tgtTemps[2] = target.getVertices()[target.getIndices()[tgtTriIndex * 3 + 2]];
+      tgtTemps[0] = target.getVertices()[target.getTriangleIndices()[tgtTriIndex * 3 + 0]];
+      tgtTemps[1] = target.getVertices()[target.getTriangleIndices()[tgtTriIndex * 3 + 1]];
+      tgtTemps[2] = target.getVertices()[target.getTriangleIndices()[tgtTriIndex * 3 + 2]];
 
       if (srcTemps[0].invMass != 0)
          srcTemps[0].position.set(tgtTemps[0]);




Index: Intersection.java
===================================================================
RCS file: /cvs/jme/src/com/jme/intersection/Intersection.java,v
retrieving revision 1.20
diff -u -r1.20 Intersection.java
--- Intersection.java   10 Sep 2004 22:36:08 -0000   1.20
+++ Intersection.java   11 Dec 2004 15:02:43 -0000
@@ -82,8 +82,8 @@
     */
    public static boolean meshIntersection(TriMesh a, TriMesh b) {
 
-      int[] indexA = a.getIndices();
-      int[] indexB = b.getIndices();
+      int[] indexA = a.getTriangleIndices();
+      int[] indexB = b.getTriangleIndices();
       TransformMatrix aTransform = new TransformMatrix();
       aTransform.setRotationQuaternion(a.getWorldRotation());
       aTransform.setTranslation(a.getWorldTranslation());
@@ -102,9 +102,10 @@
       for (int i = 0; i < vertB.length; i++) {
          vertB[i] = bTransform.multPoint(new Vector3f(b.getVertices()[i]));
       }
-
-      for (int i = 0; i < a.getTriangleQuantity(); i++) {
-         for (int j = 0; j < b.getTriangleQuantity(); j++) {
+      int aTriangleQuantity = a.getTriangleQuantity();
+      int bTriangleQuantity = b.getTriangleQuantity();
+      for (int i = 0; i < aTriangleQuantity; i++) {
+         for (int j = 0; j < bTriangleQuantity; j++) {
             if (intersection(vertA[indexA[i * 3 + 0]],
                   vertA[indexA[i * 3 + 1]], vertA[indexA[i * 3 + 2]],
                   vertB[indexB[j * 3 + 0]], vertB[indexB[j * 3 + 1]],





Index: CompositeMesh.java
===================================================================
RCS file: /cvs/jme/src/com/jme/scene/CompositeMesh.java,v
retrieving revision 1.3
diff -u -r1.3 CompositeMesh.java
--- CompositeMesh.java   30 Nov 2004 00:32:05 -0000   1.3
+++ CompositeMesh.java   11 Dec 2004 15:03:04 -0000
@@ -387,16 +387,14 @@
     */
    public void getTriangle(int i, int[] storage) {
       int iOffset = i * 3;
-
-      if (cachedTriangleIndices == null) {
-         recreateTriangleIndices();
-      }
-      if (i < 0 || iOffset >= cachedTriangleIndices.length) {
+      int[] triangles = getTriangleIndices();
+      
+      if (i < 0 || iOffset >= triangles.length) {
          return;
       }
-      storage[0] = cachedTriangleIndices[iOffset + 0];
-      storage[1] = cachedTriangleIndices[iOffset + 1];
-      storage[2] = cachedTriangleIndices[iOffset + 2];
+      storage[0] = triangles[iOffset + 0];
+      storage[1] = triangles[iOffset + 1];
+      storage[2] = triangles[iOffset + 2];
    }
 
    /**
@@ -409,16 +407,32 @@
     */
    public void getTriangle(int i, Vector3f[] vertices) {
       int iOffset = i * 3;
-      if (cachedTriangleIndices == null) {
-         recreateTriangleIndices();
-      }
-      if (i < 0 || iOffset >= cachedTriangleIndices.length) {
+      int[] triangles = getTriangleIndices();
+      if (i < 0 || iOffset >= triangles.length) {
          return;
       }
-      vertices[0] = vertex[cachedTriangleIndices[iOffset]];
-      vertices[1] = vertex[cachedTriangleIndices[iOffset + 1]];
-      vertices[2] = vertex[cachedTriangleIndices[iOffset + 2]];
+      vertices[0] = vertex[triangles[iOffset]];
+      vertices[1] = vertex[triangles[iOffset + 1]];
+      vertices[2] = vertex[triangles[iOffset + 2]];
+   }
+   
+   /**
+    * <code>getIndices</code> get an array of triples of indices which define the
+    * triangles of trimesh; array of separate triangles is returned regardless of
+    * way in which indices are internally stored. Updates to this array have undefined
+    * effect (they may but don't have to update geometry itself). If you want to modify
+    * geometry, use getIndices method and take internal layout into account.
+    * For CompositeMesh, this method caches created triangles, so it can be called
+    * many times without a cost, as long as indices are not changed
+    * @return array of integer triples with triangles in this geometry
+    */
+   public int[] getTriangleIndices() {
+       if (cachedTriangleIndices == null) {
+         recreateTriangleIndices();
+      }
+       return cachedTriangleIndices;
    }
+   
 
    private static final long serialVersionUID = 1;
 





Index: TriMesh.java
===================================================================
RCS file: /cvs/jme/src/com/jme/scene/TriMesh.java,v
retrieving revision 1.37
diff -u -r1.37 TriMesh.java
--- TriMesh.java   30 Nov 2004 00:32:05 -0000   1.37
+++ TriMesh.java   11 Dec 2004 15:03:22 -0000
@@ -174,6 +174,18 @@
    public int[] getIndices() {
       return indices;
    }
+   
+   /**
+    * <code>getIndices</code> get an array of triples of indices which define the
+    * triangles of trimesh; array of separate triangles is returned regardless of
+    * way in which indices are internally stored. Updates to this array have undefined
+    * effect (they may but don't have to update geometry itself). If you want to modify
+    * geometry, use getIndices method and take internal layout into account
+    * @return array of integer triples with triangles in this geometry
+    */
+   public int[] getTriangleIndices() {
+       return getIndices();
+   }
 
    /**
     *





Index: ClodMesh.java
===================================================================
RCS file: /cvs/jme/src/com/jme/scene/lod/ClodMesh.java,v
retrieving revision 1.17
diff -u -r1.17 ClodMesh.java
--- ClodMesh.java   14 Sep 2004 21:52:23 -0000   1.17
+++ ClodMesh.java   11 Dec 2004 15:03:42 -0000
@@ -86,7 +86,7 @@
       CollapseRecord[] records) {
 
     this(name, data.getVertices(), data.getNormals(), data.getColors(),
-         data.getTextures(), data.getIndices(), records);
+         data.getTextures(), data.getTriangleIndices(), records);
 
   }
 
@@ -132,7 +132,7 @@
         this.records = records;
       } else {
         ClodCreator creator = new ClodCreator(this.getVertices(), this.getNormals(), this.getColors(), this.getTextures(),
-                                  this.getIndices());
+                                  this.getTriangleIndices());
         this.records = creator.getRecords();
         creator.removeAllTriangles();
         creator = null;




Index: CompositeSphere.java
===================================================================
RCS file: /cvs/jme/src/com/jme/scene/shape/CompositeSphere.java,v
retrieving revision 1.1
diff -u -r1.1 CompositeSphere.java
--- CompositeSphere.java   17 Nov 2004 21:45:34 -0000   1.1
+++ CompositeSphere.java   11 Dec 2004 15:04:01 -0000
@@ -278,14 +278,14 @@
          iZStart += (radialSamples + 1);
          int i2 = iZStart;
          for (int i = 0; i <= radialSamples; i++) {
-            indices[index++] = i0+i;
-            indices[index++] = i2+i;
+             indices[index++] = i2+i;
+             indices[index++] = i0+i;
          }
       }
 
       // south pole triangles (triangle fan)
       indices[index++] = vertex.length - 2;
-      for (int i = 0; i <= radialSamples; i++) {
+      for (int i = radialSamples; i >= 0; i--) {
          indices[index++] = i;
       }
 

Cool, will this simply speed things up or does it change behavior at all? I’ll try it later when I’m back home.

No speed up - just correctness.

I’ve implemented this locally and looks good. Since it is a “fix”, I’ll commit it when I next commit to jME.