move boilerplate bucket code to memory file

4 files changed, 59 insertions, 41 deletions

diff --git a/src/asset-manager.cpp b/src/asset-manager.cpp
index 37a2a17..dcfde4d 100644
--- a/src/asset-manager.cpp
+++ b/src/asset-manager.cpp
@@ -2,30 +2,14 @@
 #include "asset-manager.hpp"
 
 TypeSafeInt_B(AssetHandle);
-constexpr AssetHandle_T AssetIndexer_T{1ULL << 32};
-constexpr AssetHandle AssetIndexer{AssetIndexer_T};
-constexpr AssetHandle_T AssetIndexMax_T{63ULL << 32};
-constexpr AssetHandle AssetIndexMax{AssetIndexMax_T};
-constexpr AssetHandle_T AssetBucketMask_T{0x00000000FFFFFFFF};
-constexpr AssetHandle AssetBucketMask{AssetBucketMask_T};
-constexpr AssetHandle_T AssetIndexMask_T{0xFFFFFFFF00000000};
-constexpr AssetHandle AssetIndexMask{AssetIndexMask_T};
-
-static inline constexpr AssetHandle_T GetBucketIndex(AssetHandle assetHandle) {
-	return static_cast<AssetHandle_T>(assetHandle & AssetBucketMask);
-}
-static inline constexpr AssetHandle_T GetAssetIndex(AssetHandle assetHandle) {
-	AssetHandle_T index = static_cast<AssetHandle_T>(assetHandle & AssetIndexMask);
-	return index >> 32;
-}
 
 struct AssetBucket {
-	Asset assets[64];
+	Asset assets[256];
 };
 
 uint64_t bucketIncrementer = 2;
-AssetHandle bucketCounter{0};
-AssetHandle assetCounter{0};
+AssetHandle_T bucketCounter{0};
+AssetHandle_T assetCounter{0};
 AssetBucket *assetBuckets = nullptr;
 
 void AssetManagerInit() {
@@ -33,29 +17,14 @@ void AssetManagerInit() {
 }
 
 AssetHandle RegisterAsset_Inner(const void *src, void *dst, int64_t size, const char *key) {
-	AssetHandle assetHandle{assetCounter | bucketCounter};
 
-	// update our counters and buckets
-	{
-		assetCounter = assetCounter + AssetIndexer;
-		if (assetCounter > AssetIndexMax) {
-			assetCounter = AssetHandle{0};
-			++bucketCounter;
-		}
-		if (bucketCounter > AssetHandle{bucketIncrementer}) {
-			int64_t newIncrement = bucketIncrementer * 1.5;
-			AssetBucket *newBuckets = pke::PkeNew<AssetBucket>(newIncrement);
-			memcpy(newBuckets, assetBuckets, sizeof(AssetBucket) * bucketIncrementer);
-			pke::PkeDelete<AssetBucket>(assetBuckets, bucketIncrementer);
-			assetBuckets = newBuckets;
-			bucketIncrementer = newIncrement;
-		}
-	}
+	AssetHandle_T assetHandle_T{Buckets_NewHandle<AssetBucket>(256ULL, bucketIncrementer, bucketCounter, assetCounter, assetBuckets)};
+	AssetHandle assetHandle{assetHandle_T};
 
 	if (src != nullptr) {
 		std::memcpy(dst, src, size);
 	}
-	Asset *asset = &assetBuckets[GetBucketIndex(assetHandle)].assets[GetAssetIndex(assetHandle)];
+	Asset *asset = &assetBuckets[Buckets_GetBucketIndex(assetHandle_T)].assets[Buckets_GetItemIndex(assetHandle_T)];
 	asset->ptr = dst;
 	asset->size = size;
 	int64_t keyLen = std::strlen(key);
@@ -81,7 +50,8 @@ AssetHandle RegisterAsset(const char *path) {
 
 	int64_t pathLen = strlen(path);
 	auto assetHandle = RegisterAsset_Inner(nullptr, target, 0, path + (pathLen > 16 ? pathLen - 16 : 0));
-	Asset *asset = &assetBuckets[GetBucketIndex(assetHandle)].assets[GetAssetIndex(assetHandle)];
+	AssetHandle_T assetHandle_T = static_cast<AssetHandle_T>(assetHandle);
+	Asset *asset = &assetBuckets[Buckets_GetBucketIndex(assetHandle_T)].assets[Buckets_GetItemIndex(assetHandle_T)];
 	file.seekg(0);
 	file.read(static_cast<char *>(asset->ptr), fileSize);
 	file.close();
@@ -90,12 +60,22 @@ AssetHandle RegisterAsset(const char *path) {
 }
 
 void DestroyAsset(AssetHandle assetHandle) {
-	Asset *asset = &assetBuckets[GetBucketIndex(assetHandle)].assets[GetAssetIndex(assetHandle)];
+	AssetHandle_T assetHandle_T = static_cast<AssetHandle_T>(assetHandle);
+	auto itemIndex = Buckets_GetItemIndex(assetHandle_T);
+	Asset *asset = &assetBuckets[Buckets_GetBucketIndex(assetHandle_T)].assets[itemIndex];
 	pke::PkeDelete(asset->ptr, asset->size);
+	for (long i = 0; i < 16; ++i) {
+		asset->key[i] = 0;
+	}
+	asset->size = 0;
 	asset->ptr = CAFE_BABE(void);
+	if (itemIndex == assetCounter - (1ULL << 32)) {
+		assetCounter -= (1ULL << 32);
+	}
 }
 
 const Asset *GetAsset(AssetHandle assetHandle) {
-	return &assetBuckets[GetBucketIndex(assetHandle)].assets[GetAssetIndex(assetHandle)];
+	AssetHandle_T assetHandle_T = static_cast<AssetHandle_T>(assetHandle);
+	return &assetBuckets[Buckets_GetBucketIndex(assetHandle_T)].assets[Buckets_GetItemIndex(assetHandle_T)];
 }
 
diff --git a/src/asset-manager.hpp b/src/asset-manager.hpp
index 8a45d48..8064697 100644
--- a/src/asset-manager.hpp
+++ b/src/asset-manager.hpp
@@ -12,7 +12,7 @@
 TypeSafeInt_H(AssetHandle, uint64_t, UINT64_MAX);
 
 struct Asset{
-	char key[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+	char key[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
 	int64_t size = 0;
 	void *ptr = nullptr;
 };
diff --git a/src/memory.cpp b/src/memory.cpp
index f919770..7670b2f 100644
--- a/src/memory.cpp
+++ b/src/memory.cpp
@@ -105,3 +105,23 @@ void pke::Flush() {
 		DestroyBucket(&buckets[i + 1]);
 	}
 }
+
+uint64_t Buckets_NewHandle(std::size_t bucketBytes, uint64_t bucketItemCount, uint64_t &bucketIncrementer, uint64_t &bucketCounter, uint64_t &itemCounter, void*& buckets) {
+	uint64_t newHandle{itemCounter | bucketCounter};
+
+	itemCounter += uint64_t{1ULL << 32};
+	if (itemCounter > uint64_t{(bucketItemCount - 1) << 32}) {
+		itemCounter = 0ULL;
+		bucketCounter += 1;
+	}
+	if (bucketCounter > bucketIncrementer) {
+		int64_t newIncrement = bucketIncrementer * 1.5;
+		char * newBuckets = reinterpret_cast<char *>(pke::PkeNew(bucketBytes * newIncrement));
+		std::memcpy(newBuckets, buckets, bucketBytes * bucketIncrementer);
+		pke::PkeDelete(buckets, bucketBytes * bucketIncrementer);
+		buckets = newBuckets;
+		bucketIncrementer = newIncrement;
+	}
+
+	return newHandle;
+}
diff --git a/src/memory.hpp b/src/memory.hpp
index 83ffd8f..74e72a3 100644
--- a/src/memory.hpp
+++ b/src/memory.hpp
@@ -3,6 +3,7 @@
 
 #include "macros.hpp"
 
+#include <cstring>
 #include <cstdint>
 #include <cstdlib>
 #include <cstdio>
@@ -43,4 +44,21 @@ inline void PkeDelete(const void *ptr, long count) {
 
 } /* pke */ 
 
+uint64_t Buckets_NewHandle(std::size_t bucketBytes, uint64_t bucketItemCount, uint64_t &bucketIncrementer, uint64_t &bucketCounter, uint64_t &itemCounter, void*& buckets);
+
+template <typename T> inline uint64_t Buckets_NewHandle(uint64_t bucketItemCount, uint64_t &bucketIncrementer, uint64_t &bucketCounter, uint64_t &itemCounter, T*& buckets) {
+	void *ptr = reinterpret_cast<void *>(buckets);
+	uint64_t handle = Buckets_NewHandle(sizeof(T), bucketItemCount, bucketIncrementer, bucketCounter, itemCounter, ptr);
+	buckets = reinterpret_cast<T *>(ptr);
+	return handle;
+}
+
+static inline constexpr uint64_t Buckets_GetBucketIndex(uint64_t handle) {
+	return handle & 0x00000000FFFFFFFF;
+}
+
+static inline constexpr uint64_t Buckets_GetItemIndex(uint64_t handle) {
+	return handle >> 32;
+}
+
 #endif /* PKE_MEMORY_HPP */