Support for capped tube

[simantics/3d.git] / org.simantics.g3d / src / org / simantics / g3d / shape / Tube.java

diff --git a/org.simantics.g3d/src/org/simantics/g3d/shape/Tube.java b/org.simantics.g3d/src/org/simantics/g3d/shape/Tube.java
index 828fd2690c95e648d1c162c4701aca97eb68c67a..0300f068b601711001d5413e1fee21dd05a00902 100644 (file)
--- a/org.simantics.g3d/src/org/simantics/g3d/shape/Tube.java
+++ b/org.simantics.g3d/src/org/simantics/g3d/shape/Tube.java
@@ -29,6 +29,8 @@ public class Tube {
        Double radius = 1.0;
        int resolution = 8;
        
+       boolean cap = false;
+       
        
        public void setResolution(int resolution) {
                if (resolution > 2)
@@ -56,6 +58,10 @@ public class Tube {
        }
        
        
+       public void setCap(boolean cap) {
+               this.cap = cap;
+       }
+       
        
        public Mesh create() {
                if (vertices.size() < 2 )
@@ -66,18 +72,43 @@ public class Tube {
                for (int i = 0; i < vertices.size() - 1; i++) {
                        t.set(vertices.get(i+1));
                        t.sub(vertices.get(i));
-                       if (t.lengthSquared() < 0.0001)
+                       if (t.lengthSquared() < 0.000001)
                                throw new IllegalArgumentException("vertices at index " + i + " are too close to each other");
                }
                
-               List<Vector3d> points = new ArrayList<Vector3d>(vertices.size()*resolution);
-               List<Vector3d> normals = new ArrayList<Vector3d>(vertices.size()*resolution);
+               int vcount = vertices.size()*resolution;
+               int icount = (vertices.size()-1)*resolution*6;
+               
+               if (cap) {
+                       vcount+=2;
+                       icount+=resolution * 6;
+               }
+               
+               List<Vector3d> points = new ArrayList<Vector3d>(vcount);
+               List<Vector3d> normals = new ArrayList<Vector3d>(vcount);
                
                for (int i = 0; i < vertices.size(); i++) {
                        createCircle(i,points,normals);
                }
+               if (cap) {
+                       int l = vertices.size()-1;
+                       points.add(new Vector3d(vertices.get(0)));
+                       points.add(new Vector3d(vertices.get(l)));
+                       Vector3d n1 = new Vector3d(vertices.get(1));
+                       n1.sub(vertices.get(0));
+                       n1.normalize();
+                       normals.add(n1);
+                       
+                       Vector3d n2 = new Vector3d(vertices.get(l-1));
+                       n2.sub(vertices.get(l));
+                       n2.normalize();
+                       normals.add(n2);
+               }
+               
                
-               int index[] = new int[(vertices.size()-1)*resolution*6];
+               
+
+               int index[] = new int[icount];
                
                createIndices(index);
                List<Integer> indices = new ArrayList<Integer>();
@@ -187,6 +218,42 @@ public class Tube {
                                }
                        }
                }
+               if (cap) {
+                       int c = 0;
+                       int isi = ((vertices.size()-1) * resolution) * 6;
+                       int ivi = vertices.size() * resolution;
+                       for (int s = 0; s < resolution; s++) {
+                               int ii = isi + s*3;
+                               int iv = c*resolution + s;
+                               if (s < resolution - 1) {
+                                       index[ii+2] = iv;
+                                       index[ii+1] = iv+1;
+                                       index[ii+0] = ivi;
+                               } else {
+                                       index[ii+2] = iv;
+                                       index[ii+1] = iv+1-resolution;
+                                       index[ii+0] = ivi;
+                               }
+                               
+                       }
+                       isi += resolution * 3;
+                       c = (vertices.size()-1);
+                       for (int s = 0; s < resolution; s++) {
+                               int ii = isi + s*3;
+                               int iv = c*resolution + s;
+                               if (s < resolution - 1) {
+                                       index[ii+2] = iv;
+                                       index[ii+1] = iv+1;
+                                       index[ii+0] = ivi+1;
+                               } else {
+                                       index[ii+2] = iv;
+                                       index[ii+1] = iv+1-resolution;
+                                       index[ii+0] = ivi+1;
+                               }
+                               
+                       }
+                       
+               }
        }
 
 }