From 09dd4bd6834861791008e66652826a66724efa0e Mon Sep 17 00:00:00 2001
From: gareth
Date: Tue, 27 Feb 2007 23:00:49 +0000
Subject: Brought in code from branches/gareth

---
 src/types/BitPack.cs  | 138 ++++++++++++++++++++++++++++++++++++++++++++++++++
 src/types/Mesh.cs     |  28 ++++++++++
 src/types/Triangle.cs |  28 ++++++++++
 3 files changed, 194 insertions(+)
 create mode 100644 src/types/BitPack.cs
 create mode 100644 src/types/Mesh.cs
 create mode 100644 src/types/Triangle.cs

(limited to 'src/types')

diff --git a/src/types/BitPack.cs b/src/types/BitPack.cs
new file mode 100644
index 0000000..1abbcf0
--- /dev/null
+++ b/src/types/BitPack.cs
@@ -0,0 +1,138 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace OpenSim.types
+{
+    /* New Method
+     * 
+     * 1. Get all the individual bytes and their bitlength, put them in a dictionary
+     * 2. Mash together when wanted.
+     * 
+     * */
+    public class Bits {
+        public byte[] data;
+        public int len;
+    }
+
+    public class InverseBitPack
+    {
+        private List<Bits> bits;
+
+        public InverseBitPack()
+        {
+            bits = new List<Bits>();
+        }
+    }
+
+    public class BitPack
+    {
+        private const int MAX_BITS = 8;
+
+        private byte[] Data;
+        private int bytePos;
+        private int bitPos;
+
+        public BitPack(byte[] data, int pos) // For libsl compatibility
+        {
+            Data = data;
+            bytePos = pos;
+        }
+
+        public BitPack() // Encoding version
+        {
+
+        }
+
+        public void LoadData(byte[] data, int pos) {
+            Data = data;
+            bytePos = pos;
+            bitPos = 0;
+        }
+
+        private void PackBitsArray(byte[] bits, int bitLen)
+        {
+            int offset = bitPos % MAX_BITS;
+            int i;
+            byte temp1;
+            byte temp2;
+
+            for (i = 0; i < bits.Length; i++)
+            {
+                int Byte = bits[i];
+                Byte <<= offset;
+                temp1 = (byte)(Byte & 0xFF);
+                temp2 = (byte)((Byte >> 8) & 0xFF);
+
+                Data[Data.Length - 1] |= temp1;
+//                Data
+
+                bitPos += bitLen;
+            }
+        }
+
+        public float UnpackFloat()
+        {
+            byte[] output = UnpackBitsArray(32);
+
+            if (!BitConverter.IsLittleEndian) Array.Reverse(output);
+            return BitConverter.ToSingle(output, 0);
+        }
+
+        public int UnpackBits(int totalCount)
+        {
+            byte[] output = UnpackBitsArray(totalCount);
+
+            if (!BitConverter.IsLittleEndian) Array.Reverse(output);
+            return BitConverter.ToInt32(output, 0);
+        }
+
+        private byte[] UnpackBitsArray(int totalCount)
+        {
+            int count = 0;
+            byte[] output = new byte[4];
+            int curBytePos = 0;
+            int curBitPos = 0;
+
+            while (totalCount > 0)
+            {
+                if (totalCount > MAX_BITS)
+                {
+                    count = MAX_BITS;
+                    totalCount -= MAX_BITS;
+                }
+                else
+                {
+                    count = totalCount;
+                    totalCount = 0;
+                }
+
+                while (count > 0)
+                {
+                    // Shift the previous bits
+                    output[curBytePos] <<= 1;
+
+                    // Grab one bit
+                    if ((Data[bytePos] & (0x80 >> bitPos++)) != 0)
+                        ++output[curBytePos];
+
+                    --count;
+                    ++curBitPos;
+
+                    if (bitPos >= MAX_BITS)
+                    {
+                        bitPos = 0;
+                        ++bytePos;
+                    }
+                    if (curBitPos >= MAX_BITS)
+                    {
+                        curBitPos = 0;
+                        ++curBytePos;
+                    }
+                }
+            }
+
+            return output;
+        }
+    }
+}
diff --git a/src/types/Mesh.cs b/src/types/Mesh.cs
new file mode 100644
index 0000000..3e00c91
--- /dev/null
+++ b/src/types/Mesh.cs
@@ -0,0 +1,28 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace OpenSim.types
+{
+    // TODO: This will need some performance tuning no doubt.
+    public class Mesh
+    {
+        public List<Triangle> mesh;
+
+        public Mesh()
+        {
+            mesh = new List<Triangle>();
+        }
+
+        public void AddTri(Triangle tri)
+        {
+            mesh.Add(tri);
+        }
+
+        public static Mesh operator +(Mesh a, Mesh b)
+        {
+            a.mesh.AddRange(b.mesh);
+            return a;
+        }
+    }
+}
diff --git a/src/types/Triangle.cs b/src/types/Triangle.cs
new file mode 100644
index 0000000..8dfea6e
--- /dev/null
+++ b/src/types/Triangle.cs
@@ -0,0 +1,28 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Axiom.MathLib;
+
+namespace OpenSim.types
+{
+    public class Triangle
+    {
+        Vector3 a;
+        Vector3 b;
+        Vector3 c;
+
+        public Triangle()
+        {
+            a = new Vector3();
+            b = new Vector3();
+            c = new Vector3();
+        }
+
+        public Triangle(Vector3 A, Vector3 B, Vector3 C)
+        {
+            a = A;
+            b = B;
+            c = C;
+        }
+    }
+}
-- 
cgit v1.1