Esempio n. 1
0
        public unsafe static void ComputeHash128 <T>(ref T value, ref Hash128 hash) where T : struct
        {
            void *   data     = UnsafeUtility.AddressOf <T>(ref value);
            ulong    dataSize = (ulong)((long)UnsafeUtility.SizeOf <T>());
            Hash128 *hash2    = (Hash128 *)UnsafeUtility.AddressOf <Hash128>(ref hash);

            HashUnsafeUtilities.ComputeHash128(data, dataSize, hash2);
        }
Esempio n. 2
0
        public unsafe static void ComputeHash128(void *data, ulong dataSize, Hash128 *hash)
        {
            ulong u64_  = hash->u64_0;
            ulong u64_2 = hash->u64_1;

            HashUnsafeUtilities.ComputeHash128(data, dataSize, &u64_, &u64_2);
            *hash = new Hash128(u64_, u64_2);
        }
Esempio n. 3
0
        public static unsafe void ComputeHash128 <T>(ref T value, ref Hash128 hash)
            where T : struct
        {
            var data     = UnsafeUtility.AddressOf(ref value);
            var dataSize = (ulong)UnsafeUtility.SizeOf <T>();
            var hashPtr  = (Hash128 *)UnsafeUtility.AddressOf(ref hash);

            HashUnsafeUtilities.ComputeHash128(data, dataSize, hashPtr);
        }
Esempio n. 4
0
        public static unsafe void ComputeHash128(byte[] value, ref Hash128 hash)
        {
            fixed(byte *data = &value[0])
            {
                var dataSize = (ulong)value.Length;
                var hashPtr  = (Hash128 *)UnsafeUtility.AddressOf(ref hash);

                HashUnsafeUtilities.ComputeHash128(data, dataSize, hashPtr);
            }
        }
Esempio n. 5
0
        public unsafe static void ComputeHash128(byte[] value, ref Hash128 hash)
        {
            fixed(byte *ptr = &value[0])
            {
                byte *   data     = ptr;
                ulong    dataSize = (ulong)((long)value.Length);
                Hash128 *hash2    = (Hash128 *)UnsafeUtility.AddressOf <Hash128>(ref hash);

                HashUnsafeUtilities.ComputeHash128((void *)data, dataSize, hash2);
            }
        }
Esempio n. 6
0
 public static void AppendHash(
     ref Hash128 inHash,
     ref Hash128 outHash
     )
 {
     unsafe
     {
         fixed(Hash128 *outH = &outHash)
         fixed(Hash128 * message = &inHash)
         {
             HashUnsafeUtilities.ComputeHash128(message, (ulong)sizeof(Hash128), outH);
         }
     }
 }
Esempio n. 7
0
        public unsafe static void AppendHash(ref Hash128 inHash, ref Hash128 outHash)
        {
            fixed(Hash128 *ptr = &outHash)
            {
                Hash128 *hash = ptr;

                fixed(Hash128 *ptr2 = &inHash)
                {
                    Hash128 *data = ptr2;

                    HashUnsafeUtilities.ComputeHash128((void *)data, (ulong)((long)sizeof(Hash128)), hash);
                }
            }
        }
Esempio n. 8
0
        public unsafe static void QuantisedVectorHash(ref Vector3 value, ref Hash128 hash)
        {
            fixed(Hash128 *ptr = &hash)
            {
                Hash128 *hash2 = ptr;
                int *    ptr2  = stackalloc int[3];

                for (int i = 0; i < 3; i++)
                {
                    ptr2[i] = (int)(value[i] * 1000f + 0.5f);
                }
                HashUnsafeUtilities.ComputeHash128((void *)ptr2, 12uL, hash2);
            }
        }
Esempio n. 9
0
        public unsafe static void QuantisedMatrixHash(ref Matrix4x4 value, ref Hash128 hash)
        {
            fixed(Hash128 *ptr = &hash)
            {
                Hash128 *hash2 = ptr;
                int *    ptr2  = stackalloc int[16];

                for (int i = 0; i < 16; i++)
                {
                    ptr2[i] = (int)(value[i] * 1000f + 0.5f);
                }
                HashUnsafeUtilities.ComputeHash128((void *)ptr2, 64uL, hash2);
            }
        }
Esempio n. 10
0
        public static void QuantisedVectorHash(ref Vector3 value, ref Hash128 hash)
        {
            unsafe
            {
                fixed(Hash128 *h = &hash)
                {
                    // Transform matrix.
                    int *quantisedVector = stackalloc int[3];

                    for (int i = 0; i < 3; ++i)
                    {
                        quantisedVector[i] = (int)((value[i] * 1000) + .5f);
                    }

                    HashUnsafeUtilities.ComputeHash128(quantisedVector, sizeof(int) * 3, h);
                }
            }
        }
Esempio n. 11
0
        public static void QuantisedMatrixHash(ref Matrix4x4 value, ref Hash128 hash)
        {
            unsafe
            {
                fixed(Hash128 *h = &hash)
                {
                    // Transform matrix.
                    int *quantisedMatrix = stackalloc int[16];

                    for (int i = 0; i < 16; ++i)
                    {
                        quantisedMatrix[i] = (int)((value[i] * 1000) + .5f);
                    }

                    HashUnsafeUtilities.ComputeHash128(quantisedMatrix, sizeof(int) * 16, h);
                }
            }
        }