checkpoint - handle breaking ECS changes - compiles

1 files changed, 56 insertions, 22 deletions

diff --git a/src/ecs.cpp b/src/ecs.cpp
index 02f00d3..f499835 100644
--- a/src/ecs.cpp
+++ b/src/ecs.cpp
@@ -1,6 +1,7 @@
 
 #include "ecs.hpp"
 
+#include "array.hpp"
 #include "bucketed-array.hpp"
 #include "game-settings.hpp"
 #include "math-helpers.hpp"
@@ -39,7 +40,8 @@ DynArray<Entity_Base *> entitiesYetToBeRemoved{0, nullptr};
 
 DynArray<Entity_Base *> EntitiesWithExcessInstances{16};
 
-BucketContainer<Entity_Base *, GrBindsHandle> Entities_BucketContainer{};
+BucketContainer<Entity_Base, PkeHandle> Entities_GenericsBC{};
+BucketContainer<Entity_Base *, EntityHandle> Entities_BucketContainer{};
 BucketContainer<CompGrBinds, GrBindsHandle> Comp_GrBinds_BucketContainer{};
 BucketContainer<CompInstance, InstanceHandle> Comp_Instance_BucketContainer{};
 
@@ -54,8 +56,14 @@ void ECS_Init() {
 	Buckets_Init(Comp_Instance_BucketContainer, maxBucketItemCount);
 }
 
+Entity_Base *ECS_CreateGenericEntity() {
+	PkeHandle newHandle{Buckets_NewHandle(Entities_GenericsBC)};
+	return &Entities_GenericsBC.buckets[newHandle.bucketIndex][newHandle.itemIndex];
+}
+
 EntityHandle ECS_CreateEntity(Entity_Base *entity, Entity_Base *parentEntity) {
 	assert(entity != nullptr);
+	assert(entity->handle == EntityHandle_MAX && "Entity already created!");
 	EntityHandle entityHandle{Buckets_NewHandle(Entities_BucketContainer)};
 	entity->handle = entityHandle;
 	entity->parentHandle = parentEntity->handle;
@@ -63,6 +71,11 @@ EntityHandle ECS_CreateEntity(Entity_Base *entity, Entity_Base *parentEntity) {
 	return entityHandle;
 }
 
+Entity_Base *ECS_GetEntity(EntityHandle handle) {
+	ValidateHandle(handle, Entities_BucketContainer.pkeHandle, Entities_BucketContainer.limits.itemIndex);
+	return Entities_BucketContainer.buckets[handle.bucketIndex][handle.itemIndex];
+}
+
 void ECS_MarkForRemoval(Entity_Base *entity) {
 	assert(entity->isMarkedForRemoval == false && "Entity already marked for removal");
 	entitiesMarkedForRemoval.Push(entity);
@@ -327,41 +340,35 @@ void ECS_Tick_Late(double delta) {
 	}
 }
 
-void ECS_HandleCollision(InstanceHandle lhs, InstanceHandle rhs) {
-	CompInstance *lhsInst = ECS_GetInstance(lhs);
-	CompGrBinds *lhsGrBinds = nullptr;
-	if (lhsInst != nullptr) {
-		lhsGrBinds = ECS_GetGrBinds(lhsInst->grBindsHandle);
-	}
+void ECS_HandleCollision(CompInstance *lhsInst, CompInstance *rhsInst) {
+	assert(lhsInst != nullptr);
+	assert(rhsInst != nullptr);
 
-	CompInstance *rhsInst = ECS_GetInstance(rhs);
-	CompGrBinds *rhsGrBinds = nullptr;
-	if (rhsInst != nullptr) {
-		rhsGrBinds = ECS_GetGrBinds(rhsInst->grBindsHandle);
-	}
+	CompGrBinds *lhsGrBinds = ECS_GetGrBinds(lhsInst->grBindsHandle);
+	CompGrBinds *rhsGrBinds = ECS_GetGrBinds(rhsInst->grBindsHandle);
 
-	void (*lhsColFunc)(InstanceHandle, InstanceHandle) = nullptr;
-	void (*rhsColFunc)(InstanceHandle, InstanceHandle) = nullptr;
+	void (*lhsColFunc)(CompInstance*, CompInstance*) = nullptr;
+	void (*rhsColFunc)(CompInstance*, CompInstance*) = nullptr;
 
 	if (lhsInst && lhsInst->collisionCallback.func != nullptr) {
-		lhsColFunc = reinterpret_cast<void (*)(InstanceHandle, InstanceHandle)>(lhsInst->collisionCallback.func);
+		lhsColFunc = reinterpret_cast<void (*)(CompInstance *, CompInstance *)>(lhsInst->collisionCallback.func);
 	}
 	if (lhsColFunc == nullptr && lhsGrBinds && lhsGrBinds->collisionCallback.func) {
-		lhsColFunc = reinterpret_cast<void (*)(InstanceHandle, InstanceHandle)>(lhsGrBinds->collisionCallback.func);
+		lhsColFunc = reinterpret_cast<void (*)(CompInstance *, CompInstance *)>(lhsGrBinds->collisionCallback.func);
 	}
 
 	if (rhsInst && rhsInst->collisionCallback.func != nullptr) {
-		rhsColFunc = reinterpret_cast<void (*)(InstanceHandle, InstanceHandle)>(rhsInst->collisionCallback.func);
+		rhsColFunc = reinterpret_cast<void (*)(CompInstance *, CompInstance *)>(rhsInst->collisionCallback.func);
 	}
 	if (rhsColFunc == nullptr && rhsGrBinds && rhsGrBinds->collisionCallback.func) {
-		rhsColFunc = reinterpret_cast<void (*)(InstanceHandle, InstanceHandle)>(rhsGrBinds->collisionCallback.func);
+		rhsColFunc = reinterpret_cast<void (*)(CompInstance *, CompInstance *)>(rhsGrBinds->collisionCallback.func);
 	}
 
 	if (lhsColFunc) {
-		lhsColFunc(lhs, rhs);
+		lhsColFunc(lhsInst, rhsInst);
 	}
 	if (rhsColFunc) {
-		rhsColFunc(lhs, rhs);
+		rhsColFunc(lhsInst, rhsInst);
 	}
 }
 
@@ -383,6 +390,19 @@ CompGrBinds *ECS_GetGrBinds(GrBindsHandle grBindsHandle) {
 	return &Comp_GrBinds_BucketContainer.buckets[grBindsHandle.bucketIndex][grBindsHandle.itemIndex];
 }
 
+void ECS_GetGrBinds(Entity_Base *entity, PkeArray<CompGrBinds *> &arr) {
+	for (PkeHandleBucketIndex_T b = 0; b <= Comp_GrBinds_BucketContainer.pkeHandle.bucketIndex; ++b) {
+		auto &bkt = Comp_GrBinds_BucketContainer.buckets[b];
+		long itemCount = Comp_GrBinds_BucketContainer.pkeHandle.bucketIndex == b ? Comp_GrBinds_BucketContainer.pkeHandle.itemIndex : Comp_GrBinds_BucketContainer.limits.itemIndex;
+		for (PkeHandleItemIndex_T i = 0; i < itemCount; ++i) {
+			auto &grBinds = bkt[i];
+			if (grBinds.entHandle == entity->handle) {
+				PkeArray_Add(&arr, &grBinds);
+			}
+		}
+	}
+}
+
 uint64_t ECS_GetGrBinds_BucketCount() {
 	return Comp_GrBinds_BucketContainer.pkeHandle.bucketIndex + 1;
 }
@@ -427,6 +447,19 @@ CompInstance *ECS_GetInstance(InstanceHandle instanceHandle ) {
 	return inst;
 }
 
+void ECS_GetInstances(Entity_Base *entity, PkeArray<CompInstance *> &arr) {
+	for (PkeHandleBucketIndex_T b = 0; b <= Comp_Instance_BucketContainer.pkeHandle.bucketIndex; ++b) {
+		auto &bkt = Comp_Instance_BucketContainer.buckets[b];
+		long itemCount = Comp_Instance_BucketContainer.pkeHandle.bucketIndex == b ? Comp_Instance_BucketContainer.pkeHandle.itemIndex : Comp_Instance_BucketContainer.limits.itemIndex;
+		for (PkeHandleItemIndex_T i = 0; i < itemCount; ++i) {
+			auto &inst = bkt[i];
+			if (inst.entHandle == entity->handle) {
+				PkeArray_Add(&arr, &inst);
+			}
+		}
+	}
+}
+
 void ECS_UpdateInstance(CompInstance *instance, const InstPos &instPos, bool overridePhysics) {
 	if (BtDynamicsWorld && overridePhysics) {
 		btVector3 localInertia(0, 0, 0);
@@ -460,7 +493,8 @@ void ECS_Teardown() {
 	entitiesYetToBeRemoved.~DynArray();
 	EntitiesToBeRemoved.~DynArray();
 	entitiesMarkedForRemoval.~DynArray();
-	Buckets_Destroy(Entities_BucketContainer);
-	Buckets_Destroy(Comp_GrBinds_BucketContainer);
 	Buckets_Destroy(Comp_Instance_BucketContainer);
+	Buckets_Destroy(Comp_GrBinds_BucketContainer);
+	Buckets_Destroy(Entities_BucketContainer);
+	Buckets_Destroy(Entities_GenericsBC);
 }