1 files changed, 112 insertions, 4 deletions

diff --git a/OpenSim/Region/Physics/Meshing/Extruder.cs b/OpenSim/Region/Physics/Meshing/Extruder.cs
index 4d2ed4b..c7dcf33 100644
--- a/OpenSim/Region/Physics/Meshing/Extruder.cs
+++ b/OpenSim/Region/Physics/Meshing/Extruder.cs
@@ -39,9 +39,15 @@ namespace OpenSim.Region.Physics.Meshing
         public float taperTopFactorY = 1f;
         public float taperBotFactorX = 1f;
         public float taperBotFactorY = 1f;
+
         public float pushX = 0f;
         public float pushY = 0f;
 
+        // twist amount in radians.  NOT DEGREES.
+        public float twistTop = 0;
+        public float twistBot = 0;
+        public float twistMid = 0;
+
         public Mesh Extrude(Mesh m)
         {
             startParameter = float.MinValue;
@@ -50,8 +56,12 @@ namespace OpenSim.Region.Physics.Meshing
             Mesh result = new Mesh();
 
             Mesh workingPlus = m.Clone();
+            Mesh workingMiddle = m.Clone();
             Mesh workingMinus = m.Clone();
 
+            Quaternion tt = new Quaternion();
+            Vertex v2 = new Vertex(0, 0, 0);
+
             foreach (Vertex v in workingPlus.vertices)
             {
                 if (v == null)
@@ -68,8 +78,44 @@ namespace OpenSim.Region.Physics.Meshing
                 //Push the top of the object over by the Top Shear amount
                 v.X += pushX * size.X;
                 v.Y += pushY * size.X;
+
+                if (twistTop != 0)
+                {
+                    // twist and shout
+                    tt = new Quaternion(new Vertex(0, 0, 1), twistTop);
+                    v2 = v * tt;
+                    v.X = v2.X;
+                    v.Y = v2.Y;
+                    v.Z = v2.Z;
+                }
             }
 
+            foreach (Vertex v in workingMiddle.vertices)
+            {
+                if (v == null)
+                    continue;
+
+                // This is the top
+                // Set the Z + .5 to match the rest of the scale of the mesh
+                // Scale it by Size, and Taper the scaling
+                v.Z *= size.Z;
+                v.X *= (size.X * ((taperTopFactorX + taperBotFactorX) /2));
+                v.Y *= (size.Y * ((taperTopFactorY + taperBotFactorY) / 2));
+
+                v.X += (pushX / 2) * size.X;
+                v.Y += (pushY / 2) * size.X;
+                //Push the top of the object over by the Top Shear amount
+                if (twistMid != 0)
+                {
+                    // twist and shout
+                    tt = new Quaternion(new Vertex(0, 0, 1), twistMid);
+                    v2 = v * tt;
+                    v.X = v2.X;
+                    v.Y = v2.Y;
+                    v.Z = v2.Z;
+                }
+              
+            }
             foreach (Vertex v in workingMinus.vertices)
             {
                 if (v == null)
@@ -80,6 +126,16 @@ namespace OpenSim.Region.Physics.Meshing
                 v.X *= (size.X * taperBotFactorX);
                 v.Y *= (size.Y * taperBotFactorY);
                 v.Z *= size.Z;
+
+                if (twistBot != 0)
+                {
+                    // twist and shout
+                    tt = new Quaternion(new Vertex(0, 0, 1), twistBot);
+                    v2 = v * tt;
+                    v.X = v2.X;
+                    v.Y = v2.Y;
+                    v.Z = v2.Z;
+                }
             }
 
             foreach (Triangle t in workingMinus.triangles)
@@ -88,9 +144,47 @@ namespace OpenSim.Region.Physics.Meshing
             }
 
             result.Append(workingMinus);
-            result.Append(workingPlus);
+
+            result.Append(workingMiddle);
+
 
             int iLastNull = 0;
+
+            for (int i = 0; i < workingMiddle.vertices.Count; i++)
+            {
+                int iNext = (i + 1);
+
+                if (workingMiddle.vertices[i] == null) // Can't make a simplex here
+                {
+                    iLastNull = i + 1;
+                    continue;
+                }
+
+                if (i == workingMiddle.vertices.Count - 1) // End of list
+                {
+                    iNext = iLastNull;
+                }
+
+                if (workingMiddle.vertices[iNext] == null) // Null means wrap to begin of last segment
+                {
+                    iNext = iLastNull;
+                }
+
+                Triangle tSide;
+                tSide = new Triangle(workingMiddle.vertices[i], workingMinus.vertices[i], workingMiddle.vertices[iNext]);
+                result.Add(tSide);
+
+                tSide =
+                    new Triangle(workingMiddle.vertices[iNext], workingMinus.vertices[i], workingMinus.vertices[iNext]);
+                result.Add(tSide);
+            }
+            //foreach (Triangle t in workingPlus.triangles)
+            //{
+                //t.invertNormal();
+           // }
+            result.Append(workingPlus);
+
+            iLastNull = 0;
             for (int i = 0; i < workingPlus.vertices.Count; i++)
             {
                 int iNext = (i + 1);
@@ -112,14 +206,28 @@ namespace OpenSim.Region.Physics.Meshing
                 }
 
                 Triangle tSide;
-                tSide = new Triangle(workingPlus.vertices[i], workingMinus.vertices[i], workingPlus.vertices[iNext]);
+                tSide = new Triangle(workingPlus.vertices[i], workingMiddle.vertices[i], workingPlus.vertices[iNext]);
                 result.Add(tSide);
 
                 tSide =
-                    new Triangle(workingPlus.vertices[iNext], workingMinus.vertices[i], workingMinus.vertices[iNext]);
+                    new Triangle(workingPlus.vertices[iNext], workingMiddle.vertices[i], workingMiddle.vertices[iNext]);
                 result.Add(tSide);
             }
-
+            if (twistMid != 0)
+            {
+                foreach (Vertex v in result.vertices)
+                {
+                    // twist and shout
+                    if (v != null)
+                    {
+                        tt = new Quaternion(new Vertex(0, 0, -1), twistMid*2);
+                        v2 = v * tt;
+                        v.X = v2.X;
+                        v.Y = v2.Y;
+                        v.Z = v2.Z;
+                    }
+                }
+            }
             return result;
         }
     }