Cleanup

engine/core/murmur.cpp

@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) 2012-2014 Daniele Bartolini and individual contributors.
+ * License: https://github.com/taylor001/crown/blob/master/LICENSE
+ */
+
+#include "murmur.h"
+
+namespace crown
+{
+/// MurmurHash2, by Austin Appleby
+///
+/// @note
+/// This code makes a few assumptions about how your machine behaves
+///
+/// 1. We can read a 4-byte value from any address without crashing
+/// 2. sizeof(int) == 4
+///
+/// And it has a few limitations -
+///
+/// 1. It will not work incrementally.
+/// 2. It will not produce the same results on little-endian and big-endian
+///    machines.
+uint32_t murmur2_32(const void* key, size_t len, uint32_t seed)
+{
+	// 'm' and 'r' are mixing constants generated offline.
+	// They're not really 'magic', they just happen to work well.
+	const unsigned int m = 0x5bd1e995;
+	const int r = 24;
+
+	// Initialize the hash to a 'random' value
+	unsigned int h = seed ^ len;
+
+	// Mix 4 bytes at a time into the hash
+	const unsigned char * data = (const unsigned char *)key;
+
+	while(len >= 4)
+	{
+		unsigned int k = *(unsigned int *)data;
+
+		k *= m;
+		k ^= k >> r;
+		k *= m;
+
+		h *= m;
+		h ^= k;
+
+		data += 4;
+		len -= 4;
+	}
+
+	// Handle the last few bytes of the input array
+	switch(len)
+	{
+		case 3: h ^= data[2] << 16;
+		case 2: h ^= data[1] << 8;
+		case 1: h ^= data[0];
+			h *= m;
+	};
+
+	// Do a few final mixes of the hash to ensure the last few
+	// bytes are well-incorporated.
+	h ^= h >> 13;
+	h *= m;
+	h ^= h >> 15;
+
+	return h;
+}
+
+uint64_t murmur2_64(const void* key, int len, uint64_t seed)
+{
+	const uint64_t m = 0xc6a4a7935bd1e995ull;
+	const int r = 47;
+
+	uint64_t h = seed ^ (len * m);
+
+	const uint64_t * data = (const uint64_t *)key;
+	const uint64_t * end = data + (len/8);
+
+	while(data != end)
+	{
+		uint64_t k = *data++;
+
+		k *= m;
+		k ^= k >> r;
+		k *= m;
+
+		h ^= k;
+		h *= m;
+	}
+
+	const unsigned char * data2 = (const unsigned char*)data;
+
+	switch(len & 7)
+	{
+		case 7: h ^= uint64_t(data2[6]) << 48;
+		case 6: h ^= uint64_t(data2[5]) << 40;
+		case 5: h ^= uint64_t(data2[4]) << 32;
+		case 4: h ^= uint64_t(data2[3]) << 24;
+		case 3: h ^= uint64_t(data2[2]) << 16;
+		case 2: h ^= uint64_t(data2[1]) << 8;
+		case 1: h ^= uint64_t(data2[0]);
+		h *= m;
+	};
+
+	h ^= h >> r;
+	h *= m;
+	h ^= h >> r;
+
+	return h;
+}
+} // namespace crown

engine/core/murmur.h

@@ -0,0 +1,14 @@
+/*
+ * Copyright (c) 2012-2014 Daniele Bartolini and individual contributors.
+ * License: https://github.com/taylor001/crown/blob/master/LICENSE
+ */
+
+#pragma once
+
+#include "types.h"
+
+namespace crown
+{
+uint32_t murmur2_32(const void* key, size_t len, uint32_t seed = 0);
+uint64_t murmur2_64(const void* key, int len, uint64_t seed = 0);
+} // namespace crown

engine/core/strings/dynamic_string.h

@@ -5,14 +5,14 @@
 
 #pragma once
 
-#include <algorithm>
-#include <cstring>
-
 #include "assert.h"
 #include "memory.h"
 #include "string_utils.h"
 #include "array.h"
 #include "string_utils.h"
+#include "murmur.h"
+#include <algorithm>
+#include <cstring>
 
 namespace crown
 {

engine/core/strings/string_utils.h

@@ -191,125 +191,4 @@ inline double parse_double(const char* string)
 	return val;
 }
 
-/// MurmurHash2, by Austin Appleby
-///
-/// @note
-/// This code makes a few assumptions about how your machine behaves
-///
-/// 1. We can read a 4-byte value from any address without crashing
-/// 2. sizeof(int) == 4
-///
-/// And it has a few limitations -
-///
-/// 1. It will not work incrementally.
-/// 2. It will not produce the same results on little-endian and big-endian
-///    machines.
-inline uint32_t murmur2_32(const void* key, size_t len, uint32_t seed = 0)
-{
-	CE_ASSERT_NOT_NULL(key);
-
-	// 'm' and 'r' are mixing constants generated offline.
-	// They're not really 'magic', they just happen to work well.
-	const unsigned int m = 0x5bd1e995;
-	const int r = 24;
-
-	// Initialize the hash to a 'random' value
-	unsigned int h = seed ^ len;
-
-	// Mix 4 bytes at a time into the hash
-	const unsigned char * data = (const unsigned char *)key;
-
-	while(len >= 4)
-	{
-		unsigned int k = *(unsigned int *)data;
-
-		k *= m;
-		k ^= k >> r;
-		k *= m;
-
-		h *= m;
-		h ^= k;
-
-		data += 4;
-		len -= 4;
-	}
-
-	// Handle the last few bytes of the input array
-	switch(len)
-	{
-		case 3: h ^= data[2] << 16;
-		case 2: h ^= data[1] << 8;
-		case 1: h ^= data[0];
-			h *= m;
-	};
-
-	// Do a few final mixes of the hash to ensure the last few
-	// bytes are well-incorporated.
-	h ^= h >> 13;
-	h *= m;
-	h ^= h >> 15;
-
-	return h;
-}
-
-inline uint64_t murmur2_64(const void* key, int len, uint64_t seed = 0)
-{
-	const uint64_t m = 0xc6a4a7935bd1e995ull;
-	const int r = 47;
-
-	uint64_t h = seed ^ (len * m);
-
-	const uint64_t * data = (const uint64_t *)key;
-	const uint64_t * end = data + (len/8);
-
-	while(data != end)
-	{
-		uint64_t k = *data++;
-
-		k *= m;
-		k ^= k >> r;
-		k *= m;
-
-		h ^= k;
-		h *= m;
-	}
-
-	const unsigned char * data2 = (const unsigned char*)data;
-
-	switch(len & 7)
-	{
-		case 7: h ^= uint64_t(data2[6]) << 48;
-		case 6: h ^= uint64_t(data2[5]) << 40;
-		case 5: h ^= uint64_t(data2[4]) << 32;
-		case 4: h ^= uint64_t(data2[3]) << 24;
-		case 3: h ^= uint64_t(data2[2]) << 16;
-		case 2: h ^= uint64_t(data2[1]) << 8;
-		case 1: h ^= uint64_t(data2[0]);
-		h *= m;
-	};
-
-	h ^= h >> r;
-	h *= m;
-	h ^= h >> r;
-
-	return h;
-}
-
-#ifdef CROWN_DEBUG
-	inline uint32_t HASH32(const char *s, uint32_t value)
-	{
-		CE_ASSERT(murmur2_32(s, strlen(s), 0) == value, "Hash mismatch");
-		return value;
-	}
-
-	inline uint64_t HASH64(const char* s, uint64_t value)
-	{
-		CE_ASSERT(murmur2_64(s, strlen(s), 0) == value, "Hash mismatch");
-		return value;
-	}
-#else
-	#define HASH32(s, v) (v)
-	#define HASH64(s, v) (v)
-#endif
-
 } // namespace crown

engine/resource/resource_id.h

@@ -6,6 +6,7 @@
 #pragma once
 
 #include "string_utils.h"
+#include "murmur.h"
 #include <inttypes.h>
 
 namespace crown

engine/world/scene_graph.cpp

@@ -9,7 +9,7 @@
 #include "matrix4x4.h"
 #include "allocator.h"
 #include "string_utils.h"
-
+#include "murmur.h"
 #include <string.h>
 
 #define CLEAN		0