path: root/src/ecs.cpp

#include "ecs.hpp"

#include "game-settings.hpp"
#include "math-helpers.hpp"
#include "memory.hpp"
#include "physics.hpp"
#include "vendor/glm_include.hpp"
#include "window.hpp"

#include <btBulletDynamicsCommon.h>
#include <BulletCollision/CollisionShapes/btConvexHullShape.h>
#include <glm/gtc/type_ptr.hpp>

const PkeHandleItemIndex_T maxBucketItemCount = 256;

struct EntityBucket {
	Entity entities[maxBucketItemCount];
};
struct GrBindsBucket {
	CompGrBinds compGrBinds[maxBucketItemCount];
};
struct InstanceBucket {
	CompInstance instances[maxBucketItemCount];
};

/*
 * Entities that have been marked for removal by calling ECS_MarkForRemoval
 *
 * Used to build the other "removal" lists.
 */
DynArray<EntityHandle> entitiesMarkedForRemoval{16};

/*
 * Public list of entities that will be removed next tick
 *
 * Entity or child of entity that had ECS_MarkForRemoval called
 */
DynArray<EntityHandle> EntitiesToBeRemoved{16}; // public

/*
 * The entities being removed this tick
 *
 * Each of these entities has gone a full tick in the "to be removed" state
 */
DynArray<Entity> entitiesYetToBeRemoved{0, nullptr};

DynArray<EntityHandle> EntitiesWithExcessInstances{16};

BucketContainer<EntityBucket, EntityHandle> Entities_BucketContainer{};
BucketContainer<GrBindsBucket, GrBindsHandle> Comp_GrBinds_BucketContainer{};
BucketContainer<InstanceBucket, InstanceHandle> Comp_Instance_BucketContainer{};

void ECS_GetEntity_Inner(EntityHandle entHandle, Entity*& ent) {
	assert(entHandle != EntityHandle_MAX && "Unknown entity handle");
	ent = &Entities_BucketContainer.buckets[entHandle.bucketIndex].entities[entHandle.itemIndex];
}

void ECS_Init() {
	Buckets_Init(Entities_BucketContainer);
	Buckets_Init(Comp_GrBinds_BucketContainer);
	Buckets_Init(Comp_Instance_BucketContainer);
}

uint64_t ECS_GetEntities_BucketCount() {
	return Entities_BucketContainer.pkeHandle.bucketIndex + 1;
}
Entity *ECS_GetEntities(uint64_t bucketIndex, uint64_t &itemCount) {
	assert(bucketIndex <= Entities_BucketContainer.pkeHandle.bucketIndex);
	itemCount = bucketIndex == Entities_BucketContainer.pkeHandle.bucketIndex ? Entities_BucketContainer.pkeHandle.itemIndex : maxBucketItemCount;
	return Entities_BucketContainer.buckets[bucketIndex].entities;
}

EntityHandle ECS_CreateEntity_Inner(EntityHandle parentEntHandle) {
	bool moved;
	EntityHandle entityHandle{Buckets_NewHandle<EntityBucket>(maxBucketItemCount, Entities_BucketContainer, moved)};

	Entity *entity = &Entities_BucketContainer.buckets[entityHandle.bucketIndex].entities[entityHandle.itemIndex];
	entity = new (entity) Entity{};
	entity->handle = entityHandle;
	entity->parentHandle = parentEntHandle;

	return entityHandle;
}

EntityHandle ECS_CreateEntity(EntityHandle parentEntHandle) {
	return ECS_CreateEntity_Inner(parentEntHandle);
}

void ECS_MarkForRemoval(EntityHandle entityHandle) {
	const Entity *ent = &Entities_BucketContainer.buckets[entityHandle.bucketIndex].entities[entityHandle.itemIndex];
	assert(ent->isMarkedForRemoval == false && "Entity already marked for removal");
	entitiesMarkedForRemoval.Push(entityHandle);
}

void ECS_Tick_Early(double delta) {
	// these reserves might happen 1 tick early, but that's fine
	entitiesYetToBeRemoved.Reserve(entitiesMarkedForRemoval.Count());
	EntitiesToBeRemoved.Resize(entitiesMarkedForRemoval.Count());
	memcpy(EntitiesToBeRemoved.GetPtr(), entitiesMarkedForRemoval.GetPtr(), sizeof(EntityHandle) * entitiesMarkedForRemoval.Count());
	entitiesYetToBeRemoved.Resize(0);
	for (long b = 0; b <= Entities_BucketContainer.pkeHandle.bucketIndex; ++b) {
		uint64_t entCount = b == Entities_BucketContainer.pkeHandle.bucketIndex ? Entities_BucketContainer.pkeHandle.itemIndex : maxBucketItemCount;
		for (long e  = 0; e < entCount; ++e) {
			Entity *ent = &Entities_BucketContainer.buckets[b].entities[e];
			if (ent->handle == EntityHandle_MAX) continue;
			if (ent->isMarkedForRemoval) {
				entitiesYetToBeRemoved.Push(*ent);
				ent->handle = EntityHandle_MAX;
				ent->parentHandle = EntityHandle_MAX;
				ent->isMarkedForRemoval = false;
			} else if (EntitiesToBeRemoved.Has(ent->handle)) {
				ent->isMarkedForRemoval = true;
		  } else if (EntitiesToBeRemoved.Has(ent->parentHandle)) {
				ent->isMarkedForRemoval = true;
				EntitiesToBeRemoved.Push(ent->handle);
			}
		}
	}
	for (long e = 0; e < entitiesYetToBeRemoved.Count(); ++e) {
		Entity &clonedEnt = entitiesYetToBeRemoved[e];
		CompGrBinds *grBinds = nullptr;
		InstanceBucket *instBucket = nullptr;
		CompInstance *inst = nullptr;
		uint64_t instBucketIndex = 0;
		if (clonedEnt.instanceHandle != InstanceHandle_MAX) {
			instBucketIndex = clonedEnt.instanceHandle.bucketIndex;
			instBucket = &Comp_Instance_BucketContainer.buckets[instBucketIndex];
			inst = &instBucket->instances[clonedEnt.instanceHandle.itemIndex];
			grBinds = &Comp_GrBinds_BucketContainer.buckets[inst->grBindsHandle.bucketIndex].compGrBinds[inst->grBindsHandle.itemIndex];
		}
		if (grBinds == nullptr && clonedEnt.grBindsHandle != GrBindsHandle_MAX) {
			grBinds = &Comp_GrBinds_BucketContainer.buckets[clonedEnt.grBindsHandle.bucketIndex].compGrBinds[clonedEnt.grBindsHandle.itemIndex];
		}
		if (inst != nullptr) {
			assert(grBinds != nullptr);
			for (long bi = instBucketIndex; bi <= Comp_Instance_BucketContainer.pkeHandle.bucketIndex; ++bi) {
				uint64_t instCounter = 0;
				if (bi == Comp_Instance_BucketContainer.pkeHandle.bucketIndex) {
					instCounter = Comp_Instance_BucketContainer.pkeHandle.itemIndex;
				} else {
					instCounter = maxBucketItemCount;
				}
				auto &bucket = Comp_Instance_BucketContainer.buckets[bi];
				for (long ii = 0; ii < instCounter; ++ii) {
					if (bucket.instances[ii].entHandle == EntityHandle_MAX) {
						continue;
					}
					if (bucket.instances[ii].grBindsHandle != clonedEnt.grBindsHandle) {
						continue;
					}
					if (bucket.instances[ii].instanceHandle.itemIndex < clonedEnt.instanceHandle.itemIndex) {
						continue;
					}
					bucket.instances[ii].index -= 1;
					bucket.instances[ii].isNeedingUpdated = true;
				}
			}
			grBinds->instanceCounter -= 1;
			inst->entHandle = EntityHandle_MAX;
			inst->grBindsHandle = GrBindsHandle_MAX;
			inst->index = ECS_UNSET_VAL;
			inst->instanceHandle = InstanceHandle_MAX;
			inst->isNeedingUpdated = false;
			BtDynamicsWorld->removeRigidBody(inst->bt.rigidBody);
			Pke_Delete<btDefaultMotionState>(inst->bt.motionState, MemBkt_Bullet);
			Pke_Delete<btRigidBody>(inst->bt.rigidBody, MemBkt_Bullet);
		} else if (grBinds != nullptr) {
			/*
			 * 2023-09-05 JB note - the Vulkan assets (device memory, buffers,
			 *  pipeline layout, and descriptor set) are unloaded elsewhere, just,
			 *  as they were created elsewhere.
			 */
		}
	}
	entitiesMarkedForRemoval.Resize(0);
}

void ECS_Tick(double delta) {
	int32_t physicsTickCount = Physics_Tick(delta);
	if (physicsTickCount != 0) {
		for (long b = 0; b <= Comp_Instance_BucketContainer.pkeHandle.bucketIndex; ++b) {
			auto &bkt = Comp_Instance_BucketContainer.buckets[b];
			long count = Comp_Instance_BucketContainer.pkeHandle.bucketIndex == b ? Comp_Instance_BucketContainer.pkeHandle.itemIndex : maxBucketItemCount;
			for (uint32_t i = 0; i < count; ++i) {
				auto &inst = bkt.instances[i];
				if (inst.entHandle == EntityHandle_MAX)
					continue;
				auto activationState = inst.bt.rigidBody->getActivationState();
				if (activationState == ISLAND_SLEEPING || activationState == DISABLE_SIMULATION || activationState == WANTS_DEACTIVATION) {
					continue;
				}
				inst.isNeedingUpdated = true;
			}
		}
	}
}

struct InstanceBufferCopyChunk {
	uint64_t startingIndex;
	uint64_t endingIndex;
	DynArray<glm::mat4> *mats = nullptr;
	VkBufferCopy dstBufferCopy;
};
struct InstanceBufferCopy {
	CompGrBinds *grBinds = nullptr;
	VkDeviceSize runningSize = 0;
	DynArray<InstanceBufferCopyChunk> *chunks = nullptr;
};
void ECS_Tick_Late(double delta) {
	// using a pointer here avoids calling the destructor when the object goes out of scope
	DynArray<InstanceBufferCopy> *bufferUpdatesPtr = Pke_New<DynArray<InstanceBufferCopy>>(pkeSettings.mem.bkt);
	new (bufferUpdatesPtr) DynArray<InstanceBufferCopy>(0, pkeSettings.mem.bkt);
	DynArray<InstanceBufferCopy> &bufferUpdates = *bufferUpdatesPtr;
	for (long b = 0; b <= Comp_Instance_BucketContainer.pkeHandle.bucketIndex; ++b) {
		auto &bkt = Comp_Instance_BucketContainer.buckets[b];
		long count = Comp_Instance_BucketContainer.pkeHandle.bucketIndex == b ? Comp_Instance_BucketContainer.pkeHandle.itemIndex : maxBucketItemCount;
		for (uint32_t i = 0; i < count; ++i) {
			auto &inst = bkt.instances[i];
			if (inst.isNeedingUpdated == false)
				continue;
			if (inst.entHandle == EntityHandle_MAX)
				continue;

			auto &grBinds = Comp_GrBinds_BucketContainer.buckets[inst.grBindsHandle.bucketIndex].compGrBinds[inst.grBindsHandle.itemIndex];

			InstanceBufferCopy *bfrUpdate = nullptr;
			for (long u = 0; u < bufferUpdates.Count(); ++u) {
				if (bufferUpdates[u].grBinds->grBindsHandle == inst.grBindsHandle) {
					bfrUpdate = &bufferUpdates[u];
				}
			}
			if (bfrUpdate == nullptr) {
				bufferUpdates.Push({
					.grBinds = &grBinds,
				});
				bfrUpdate = &bufferUpdates[bufferUpdates.Count() - 1];
				bfrUpdate->chunks = Pke_New<DynArray<InstanceBufferCopyChunk>>(pkeSettings.mem.bkt);
				new (bfrUpdate->chunks) DynArray<InstanceBufferCopyChunk>(4, pkeSettings.mem.bkt);
			}

			InstanceBufferCopyChunk *chunk = nullptr;
			for (long ii = 0; ii < bfrUpdate->chunks->Count(); ++ii) {
				if ((*bfrUpdate->chunks)[ii].endingIndex == inst.index - 1) {
					chunk = &(*bfrUpdate->chunks)[ii];
					chunk->endingIndex += 1;
					break;
				}
			}
			if (chunk == nullptr) {
				bfrUpdate->chunks->Push({
					.startingIndex = inst.index,
					.endingIndex = inst.index,
				});
				chunk = &(*bfrUpdate->chunks)[bfrUpdate->chunks->Count() - 1];
				chunk->dstBufferCopy.dstOffset = sizeof(glm::mat4) * inst.index;
				chunk->mats = Pke_New<DynArray<glm::mat4>>(pkeSettings.mem.bkt);
				new (chunk->mats) DynArray<glm::mat4>(0, pkeSettings.mem.bkt);
			}

			btTransform btMatrix_posRot;
			inst.bt.motionState->getWorldTransform(btMatrix_posRot);
			float openglMatrix[16];
			btMatrix_posRot.getOpenGLMatrix(openglMatrix);
			glm::mat4 glmMat_posRot = glm::make_mat4(openglMatrix);

			glm::vec3 scale;
			BulletToGlm(inst.bt.rigidBody->getCollisionShape()->getLocalScaling(), scale);

			chunk->mats->Push(glm::scale(glmMat_posRot, scale));
			bfrUpdate->runningSize += sizeof(glm::mat4);
			inst.isNeedingUpdated = false;
		}
	}
	while (bufferUpdates.Count() > 0) {
		InstanceBufferCopy &ibc = bufferUpdates[bufferUpdates.Count() - 1];

		VkDeviceSize instanceBytes = sizeof(glm::mat4);
		VkDeviceSize byteCount = ibc.runningSize;
		VkBuffer transferBuffer;
		VkDeviceMemory transferMemory;
		void *deviceData;
		BeginTransferBuffer(byteCount, transferBuffer, transferMemory, deviceData);
		VkDeviceSize runningOffset = 0;
		for (long i = 0; i < ibc.chunks->Count(); ++i) {
			auto &chunk = (*ibc.chunks)[i];
			memcpy(static_cast<char *>(deviceData) + runningOffset, chunk.mats->GetPtr(), byteCount);
			chunk.dstBufferCopy.srcOffset = runningOffset;
			chunk.dstBufferCopy.size = instanceBytes * (chunk.endingIndex - chunk.startingIndex + 1);
			runningOffset += chunk.dstBufferCopy.size;
		}
		assert(runningOffset == ibc.runningSize);

		{
			VkCommandBufferBeginInfo cbbi;
			cbbi.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
			cbbi.pNext = nullptr;
			cbbi.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
			cbbi.pInheritanceInfo = nullptr;

			vkBeginCommandBuffer(transferCommandBuffer, &cbbi);

			for (long i = 0; i < ibc.chunks->Count(); ++i) {
				vkCmdCopyBuffer(transferCommandBuffer, transferBuffer, ibc.grBinds->instanceBuffer, 1, &(*ibc.chunks)[i].dstBufferCopy);
			}

			vkEndCommandBuffer(transferCommandBuffer);

			VkSubmitInfo vkSubmitInfo{};
			vkSubmitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
			vkSubmitInfo.pNext = nullptr;
			vkSubmitInfo.waitSemaphoreCount = 0;
			vkSubmitInfo.pWaitSemaphores = nullptr;
			vkSubmitInfo.pWaitDstStageMask = nullptr;
			vkSubmitInfo.commandBufferCount = 1;
			vkSubmitInfo.pCommandBuffers = &transferCommandBuffer;
			vkSubmitInfo.signalSemaphoreCount = 0;
			vkSubmitInfo.pSignalSemaphores = nullptr;
			vkQueueSubmit(transferQueue, 1, &vkSubmitInfo, nullptr);
			vkQueueWaitIdle(transferQueue);
			vkResetCommandBuffer(transferCommandBuffer, 0);
		}
		EndTransferBuffer(transferBuffer, transferMemory);
		bufferUpdates.Pop();
	}
}

CompGrBinds &ECS_CreateGrBinds(EntityHandle entHandle) {
	assert(entHandle != EntityHandle_MAX);

	Entity *ent = nullptr;
	ECS_GetEntity_Inner(entHandle, ent);

	assert(ent->grBindsHandle == GrBindsHandle_MAX);

	bool moved;
	ent->grBindsHandle = Buckets_NewHandle(maxBucketItemCount, Comp_GrBinds_BucketContainer, moved);
	auto *comp = &Comp_GrBinds_BucketContainer.buckets[ent->grBindsHandle.bucketIndex].compGrBinds[ent->grBindsHandle.itemIndex];
	comp = new (comp) CompGrBinds{};
	comp->entHandle = entHandle;
	comp->grBindsHandle = ent->grBindsHandle;
	return *comp;
}

CompGrBinds *ECS_GetGrBinds(EntityHandle entHandle) {
	Entity *ent = nullptr;
	ECS_GetEntity_Inner(entHandle, ent);
	if (ent->grBindsHandle == GrBindsHandle_MAX) return nullptr;
	return &Comp_GrBinds_BucketContainer.buckets[ent->grBindsHandle.bucketIndex].compGrBinds[ent->grBindsHandle.itemIndex];
}
CompGrBinds *ECS_GetGrBinds(GrBindsHandle grBindsHandle) {
	if (grBindsHandle == GrBindsHandle_MAX) return nullptr;
	return &Comp_GrBinds_BucketContainer.buckets[grBindsHandle.bucketIndex].compGrBinds[grBindsHandle.itemIndex];
}

uint64_t ECS_GetGrBinds_BucketCount() {
	return Comp_GrBinds_BucketContainer.pkeHandle.bucketIndex + 1;
}

CompGrBinds *ECS_GetGrBinds(uint64_t bucketIndex, uint64_t &itemCount) {
	if (bucketIndex == Comp_GrBinds_BucketContainer.pkeHandle.bucketIndex) {
		itemCount = Comp_GrBinds_BucketContainer.pkeHandle.itemIndex;
	} else {
		itemCount = maxBucketItemCount;
	}
	return Comp_GrBinds_BucketContainer.buckets[bucketIndex].compGrBinds;
}

CompInstance &ECS_CreateInstance(EntityHandle entHandle, EntityHandle entityTypeEntityHandle) {
	assert(entHandle != EntityHandle_MAX);
	assert(entityTypeEntityHandle != EntityHandle_MAX);

	Entity *ent = nullptr;
	Entity *entTypeEnt = nullptr;
	ECS_GetEntity_Inner(entHandle, ent);
	ECS_GetEntity_Inner(entityTypeEntityHandle, entTypeEnt);

	assert(ent->grBindsHandle == GrBindsHandle_MAX);
	assert(entTypeEnt->grBindsHandle != GrBindsHandle_MAX);

	bool moved;
	ent->instanceHandle = Buckets_NewHandle(maxBucketItemCount, Comp_Instance_BucketContainer, moved);

	auto *instBkt = &Comp_Instance_BucketContainer.buckets[ent->instanceHandle.bucketIndex];
	auto *comp = &instBkt->instances[ent->instanceHandle.itemIndex];
	comp = new (comp) CompInstance{};
	comp->entHandle = entHandle;

	auto *grBinds = &Comp_GrBinds_BucketContainer.buckets[entTypeEnt->grBindsHandle.bucketIndex].compGrBinds[entTypeEnt->grBindsHandle.itemIndex];

	comp->grBindsHandle = grBinds->grBindsHandle;
	comp->instanceHandle = ent->instanceHandle;
	comp->index = grBinds->instanceCounter++;
	comp->isNeedingUpdated = true;

	if (grBinds->instanceCounter > grBinds->instanceBufferMaxCount) {
		EntitiesWithExcessInstances.Push(grBinds->entHandle);
	}

	return *comp;
}

CompInstance *ECS_GetInstance(EntityHandle entHandle) {
	Entity *ent = nullptr;
	ECS_GetEntity_Inner(entHandle, ent);
	
	if (ent->instanceHandle == InstanceHandle_MAX)
		return nullptr;

	auto *inst = &Comp_Instance_BucketContainer.buckets[ent->instanceHandle.bucketIndex].instances[ent->instanceHandle.itemIndex];

	return inst;
}

void ECS_UpdateInstance(EntityHandle entHandle, const InstPos &instPos, bool overridePhysics) {
	Entity *ent = nullptr;
	ECS_GetEntity_Inner(entHandle, ent);

	if (ent->instanceHandle == InstanceHandle_MAX)
		return;

	auto *inst = &Comp_Instance_BucketContainer.buckets[ent->instanceHandle.bucketIndex].instances[ent->instanceHandle.itemIndex];

	if (BtDynamicsWorld && overridePhysics) {
		btVector3 localInertia(0, 0, 0);
		inst->bt.rigidBody->getCollisionShape()->calculateLocalInertia(instPos.mass, localInertia);
		inst->bt.rigidBody->setMassProps(instPos.mass, localInertia);
		inst->bt.rigidBody->getMotionState()->setWorldTransform(instPos.posRot);
		inst->bt.rigidBody->setWorldTransform(instPos.posRot);
		inst->bt.rigidBody->getCollisionShape()->setLocalScaling(instPos.scale);
		inst->bt.rigidBody->setLinearVelocity(btVector3(0,0,0));
		inst->bt.rigidBody->setAngularVelocity(btVector3(0,0,0));
		inst->bt.rigidBody->activate();
		inst->isNeedingUpdated = true;
	}
}

uint64_t ECS_GetInstances_BucketCount() {
	return Comp_Instance_BucketContainer.pkeHandle.bucketIndex + 1;
}

CompInstance *ECS_GetInstances(uint64_t bucketIndex, uint64_t &itemCount) {
	if (bucketIndex == Comp_Instance_BucketContainer.pkeHandle.bucketIndex) {
		itemCount = Comp_Instance_BucketContainer.pkeHandle.itemIndex;
	} else {
		itemCount = maxBucketItemCount;
	}
	return Comp_Instance_BucketContainer.buckets[bucketIndex].instances;
}

void ECS_Teardown() {
	EntitiesWithExcessInstances.~DynArray();
	entitiesYetToBeRemoved.~DynArray();
	EntitiesToBeRemoved.~DynArray();
	entitiesMarkedForRemoval.~DynArray();
	Buckets_Destroy(Entities_BucketContainer);
	Buckets_Destroy(Comp_GrBinds_BucketContainer);
	Buckets_Destroy(Comp_Instance_BucketContainer);
}