* Adds twist support for Cubes, Cylinders, and Prisms in the Meshmerizer

* A tweak of the SimStatsReporter so it would report the prim capacity to be 45000.

1 files changed, 131 insertions, 5 deletions

diff --git a/OpenSim/Region/Physics/Meshing/HelperTypes.cs b/OpenSim/Region/Physics/Meshing/HelperTypes.cs
index 7b17a3f..efc5968 100644
--- a/OpenSim/Region/Physics/Meshing/HelperTypes.cs
+++ b/OpenSim/Region/Physics/Meshing/HelperTypes.cs
@@ -32,16 +32,136 @@ using System.Globalization;
 using OpenSim.Region.Physics.Manager;
 using OpenSim.Region.Physics.Meshing;
 
-public class Vertex : PhysicsVector, IComparable<Vertex>
+public class Quaternion
 {
-    public Vertex(float x, float y, float z)
-        : base(x, y, z)
+    public float x = 0;
+    public float y = 0;
+    public float z = 0;
+    public float w = 1;
+
+    public Quaternion()
     {
-    }
 
+    }
+    public Quaternion(float x1, float y1, float z1, float w1)
+    {
+        x = x1; y = y1; z = z1; w = w1;
+    }
+    public Quaternion(Vertex axis, float angle)
+    {
+        // using (* 0.5) instead of (/2) 
+        w = (float)Math.Cos(angle * 0.5f);
+        x = axis.X * (float)Math.Sin(angle * 0.5f);
+        y = axis.Y * (float)Math.Sin(angle * 0.5f);
+        z = axis.Z * (float)Math.Sin(angle * 0.5f);
+        normalize();
+    }
+    public static Quaternion operator *(Quaternion a, Quaternion b)
+    {
+        Quaternion c = new Quaternion();
+        c.x = a.w * b.x + a.x * b.w + a.y * b.z - a.z * b.y;
+        c.y = a.w * b.y + a.y * b.w + a.z * b.x - a.x * b.z;
+        c.z = a.w * b.z + a.z * b.w + a.x * b.y - a.y * b.x;
+        c.w = a.w * b.w - a.x * b.x - a.y * b.y - a.z * b.z;
+        return c;
+    }
+    
+    
+    public Matrix4 computeMatrix()
+    {
+        return new Matrix4(this);
+    }
+    public void normalize()
+    {
+        float mag = length();
+       
+        w /= mag;
+        x /= mag;
+        y /= mag;
+        z /= mag;
+    }
     public float length()
     {
-        return (float)Math.Sqrt(X * X + Y * Y + Z * Z);
+        return (float)Math.Sqrt(w * w + x * x + y * y + z * z);
+    }
+}
+public class Matrix4
+{
+    public float m00 = 0;
+    public float m01 = 0;
+    public float m02 = 0;
+    public float m03 = 0;
+    public float m10 = 0;
+    public float m11 = 0;
+    public float m12 = 0;
+    public float m13 = 0;
+    public float m20 = 0;
+    public float m21 = 0;
+    public float m22 = 0;
+    public float m23 = 0;
+    public float m30 = 0;
+    public float m31 = 0;
+    public float m32 = 0;
+    public float m33 = 1;
+
+    public Matrix4(float m001, float m011, float m021, float m031, float m101, float m111, float m121, float m131, float m201, float m211, float m221, float m231, float m301, float m311, float m321, float m331)
+    {
+        m00 = m001;
+        m01 = m011;
+        m02 = m021;
+        m03 = m031;
+        m10 = m101;
+        m11 = m111;
+        m12 = m121;
+        m13 = m131;
+        m20 = m201;
+        m21 = m211;
+        m22 = m221;
+        m23 = m231;
+        m30 = m301;
+        m31 = m311;
+        m32 = m321;
+        m33 = m331;
+    }
+    public Matrix4()
+    {
+    }
+    public Matrix4(Quaternion r)
+    {
+        m00 = 1 - (2 * (r.y * r.y)) - (2 * (r.z * r.z));
+        m01 = (r.x * r.y * 2) - (r.w * r.z * 2);
+        m02 = (r.x * r.z * 2) + (r.w * r.y * 2);
+        m03 = 0f;
+        m10 = (r.x * r.y * 2) + (r.w * r.z * 2);
+        m11 = 1 - (2 * (r.x * r.x)) - (2 * (r.z * r.z));
+        m12 = (r.y * r.z * 2) - (r.w * r.x * 2);
+        m13 = 0f;
+        m20 = (r.x * r.z * 2) - (r.w * r.y * 2);
+        m21 = (r.y * r.z * 2) - (r.w * r.x * 2);
+        m22 = 1 - (2 * (r.x * r.x)) - (2 * (r.y * r.y));
+        m23 = 0f;
+        m30 = 0f;
+        m31 = 0f;
+        m32 = 0f;
+        m33 = 1f;
+    }
+    public Vertex transform(Vertex o)
+    {
+        Vertex r = new Vertex(0,0,0);
+        // w value implicitly 1 therefore the last + m3x actually represents (m3x * o.W) = m3x
+        // in calculating the dot product.
+        r.X = (m00 * o.X) + (m10 * o.Y) + (m20 * o.Z) + m30;
+        r.Y = (m01 * o.X) + (m11 * o.Y) + (m21 * o.Z) + m31;
+        r.Z = (m02 * o.X) + (m12 * o.Y) + (m22 * o.Z) + m32;
+        return r;
+    }
+}
+
+public class Vertex : PhysicsVector, IComparable<Vertex>
+{
+    public Vertex(float x, float y, float z)
+        : base(x, y, z)
+    {
     }
 
     public Vertex normalize()
@@ -62,6 +182,12 @@ public class Vertex : PhysicsVector, IComparable<Vertex>
         return new Vertex(Y * v.Z - Z * v.Y, Z * v.X - X * v.Z, X * v.Y - Y * v.X);
     }
 
+    public static Vertex operator *(Vertex v, Quaternion q)
+    {
+        Matrix4 tm = q.computeMatrix();
+        return tm.transform(v);
+    }
+
     public static Vertex operator +(Vertex v1, Vertex v2)
     {
         return new Vertex(v1.X + v2.X, v1.Y + v2.Y, v1.Z + v2.Z);