instancing checkpoint

5 files changed, 109 insertions, 23 deletions

diff --git a/src/components.cpp b/src/components.cpp
index 7531dd2..03366d5 100644
--- a/src/components.cpp
+++ b/src/components.cpp
@@ -3,3 +3,4 @@
 
 TypeSafeInt_B(EntityHandle);
 TypeSafeInt_B(GrBindsHandle);
+TypeSafeInt_B(InstanceHandle);
diff --git a/src/components.hpp b/src/components.hpp
index f0a46a9..8f0d3a5 100644
--- a/src/components.hpp
+++ b/src/components.hpp
@@ -1,36 +1,65 @@
 #ifndef PKE_COMPONENTS_HPP
 #define PKE_COMPONENTS_HPP
 
-#include"macros.hpp"
+#include "macros.hpp"
+#include "dynamic-array.hpp"
+
+#include <glm/vec2.hpp>
+#include <glm/vec3.hpp>
 #include <vulkan/vulkan_core.h>
 
 const uint64_t ECS_UNSET_VAL = 0xFFFFFFFFFFFFFFFF;
 
 TypeSafeInt_H(EntityHandle, uint64_t, UINT64_MAX);
 TypeSafeInt_H(GrBindsHandle, uint64_t, UINT64_MAX);
+TypeSafeInt_H(InstanceHandle, uint64_t, UINT64_MAX);
 
 struct Entity {
 	EntityHandle handle = EntityHandle{EntityHandle_T{ECS_UNSET_VAL}};
 	EntityHandle parentHandle = EntityHandle{EntityHandle_T{ECS_UNSET_VAL}};
-	bool isMarkedForRemoval = false;
 	GrBindsHandle grBindsHandle = GrBindsHandle{GrBindsHandle_T{ECS_UNSET_VAL}};
+	InstanceHandle instanceHandle = InstanceHandle{InstanceHandle_T{ECS_UNSET_VAL}};
+	bool isMarkedForRemoval = false;
 };
 
-struct GrBindsComp {
+struct Vert {
+	glm::vec3 pos;
+	glm::vec2 tex;
+};
+
+struct InstPos {
+	glm::vec3 pos;
+	glm::vec3 rot;
+	glm::vec3 scale;
+};
+
+struct CompGrBinds {
+	GrBindsHandle grBindsHandle = GrBindsHandle{GrBindsHandle_T{ECS_UNSET_VAL}};
+	VkDeviceMemory deviceMemory = VK_NULL_HANDLE;
 	VkBuffer vertexBuffer = VK_NULL_HANDLE;
 	uint32_t vertexFirstBinding = 0;
 	uint32_t vertexCount = 0;
 	VkDeviceSize vertexOffsets = 0;
+	DynArray<Vert> vertexes{0};
 	VkBuffer indexBuffer = VK_NULL_HANDLE;
 	uint32_t indexFirstBinding = 0;
 	uint32_t indexCount = 0;
 	VkDeviceSize indexOffsets = 0;
+	DynArray<uint16_t> indexes{0};
 	VkBuffer instanceBuffer = VK_NULL_HANDLE;
 	uint32_t instanceFirstBinding = 0;
 	uint32_t instanceCount = 0;
 	VkDeviceSize instanceOffsets = 0;
+	DynArray<InstPos> instances{0};
 	VkPipelineLayout vkPipelineLayout = VK_NULL_HANDLE;
 	VkDescriptorSet vkDescriptorSet = VK_NULL_HANDLE;
 };
 
+struct CompInstance {
+	GrBindsHandle grBindsHandle = GrBindsHandle{GrBindsHandle_T{ECS_UNSET_VAL}};
+	InstanceHandle instanceHandle = InstanceHandle{InstanceHandle_T{ECS_UNSET_VAL}};
+	uint64_t index = ECS_UNSET_VAL;
+	InstPos *ptr = nullptr;
+};
+
 #endif /* PKE_COMPONENTS_HPP */
diff --git a/src/ecs.cpp b/src/ecs.cpp
index d91cd1a..1af539c 100644
--- a/src/ecs.cpp
+++ b/src/ecs.cpp
@@ -4,17 +4,21 @@
 TypeSafeInt_B(EntityHandle);
 const uint64_t maxBucketItemCount = 256;
 
-struct EntityBucket{
+struct EntityBucket {
 	Entity entities[maxBucketItemCount];
 };
-struct GrBindsBucket{
-	GrBindsComp compGrBinds[maxBucketItemCount];
+struct GrBindsBucket {
+	CompGrBinds compGrBinds[maxBucketItemCount];
+};
+struct InstanceBucket {
+	CompInstance instances[maxBucketItemCount];
 };
 
 DynArray<EntityHandle> entitiesMarkedForRemoval{16};
 DynArray<EntityHandle> EntitiesToBeRemoved{16};
 BucketContainer<EntityBucket, EntityHandle_T> Entities_BucketContainer{};
 BucketContainer<GrBindsBucket, GrBindsHandle_T> Comp_GrBinds_BucketContainer{};
+BucketContainer<InstanceBucket, InstanceHandle_T> Comp_Instance_BucketContainer{};
 
 void ECS_GetEntity_Inner(EntityHandle entHandle, Entity*& ent) {
 	EntityHandle_T entHandle_t{static_cast<EntityHandle_T>(entHandle)};
@@ -27,9 +31,10 @@ void ECS_GetEntity_Inner(EntityHandle entHandle, Entity*& ent) {
 void ECS_Init() {
 	Buckets_Init(Entities_BucketContainer);
 	Buckets_Init(Comp_GrBinds_BucketContainer);
+	Buckets_Init(Comp_Instance_BucketContainer);
 }
 
-EntityHandle ECS_CreateEntity_Inner(EntityHandle parentEntityHandle) {
+EntityHandle ECS_CreateEntity_Inner(EntityHandle parentEntHandle) {
 	EntityHandle_T entityHandle_T{Buckets_NewHandle<EntityBucket>(maxBucketItemCount, Entities_BucketContainer)};
 	EntityHandle entityHandle{entityHandle_T};
 
@@ -38,13 +43,13 @@ EntityHandle ECS_CreateEntity_Inner(EntityHandle parentEntityHandle) {
 	Entity *entity = &Entities_BucketContainer.buckets[b].entities[e];
 
 	entity->handle = entityHandle;
-	entity->parentHandle = parentEntityHandle;
+	entity->parentHandle = parentEntHandle;
 
 	return entityHandle;
 }
 
-EntityHandle ECS_CreateEntity(EntityHandle parentEntityHandle) {
-	return ECS_CreateEntity_Inner(parentEntityHandle);
+EntityHandle ECS_CreateEntity(EntityHandle parentEntHandle) {
+	return ECS_CreateEntity_Inner(parentEntHandle);
 }
 
 void ECS_MarkForRemoval(EntityHandle entityHandle) {
@@ -83,27 +88,33 @@ void ECS_Tick(double delta) {
 	entitiesMarkedForRemoval.Resize(0);
 }
 
-GrBindsComp &ECS_CreateGrBinds(EntityHandle handle) {
+CompGrBinds &ECS_CreateGrBinds(EntityHandle entHandle) {
 	Entity *ent = nullptr;
-	ECS_GetEntity_Inner(handle, ent);
+	ECS_GetEntity_Inner(entHandle, ent);
 	GrBindsHandle_T newHandle{Buckets_NewHandle(maxBucketItemCount, Comp_GrBinds_BucketContainer)};
 	ent->grBindsHandle = GrBindsHandle{newHandle};
-	return Comp_GrBinds_BucketContainer.buckets[Buckets_GetBucketIndex(newHandle)].compGrBinds[Buckets_GetItemIndex(newHandle)];
+	auto b = Buckets_GetBucketIndex(newHandle);
+	auto i = Buckets_GetItemIndex(newHandle);
+	auto &comp = Comp_GrBinds_BucketContainer.buckets[b].compGrBinds[i];
+	comp.grBindsHandle = ent->grBindsHandle;
+	return comp;
 }
 
-GrBindsComp *ECS_GetGrBinds(EntityHandle entHandle) {
+CompGrBinds *ECS_GetGrBinds(EntityHandle entHandle) {
 	Entity *ent = nullptr;
 	ECS_GetEntity_Inner(entHandle, ent);
 	GrBindsHandle_T grBindsHandle_t{static_cast<GrBindsHandle_T>(ent->grBindsHandle)};
 	if (grBindsHandle_t == ECS_UNSET_VAL) return nullptr;
-	return &Comp_GrBinds_BucketContainer.buckets[Buckets_GetBucketIndex(grBindsHandle_t)].compGrBinds[Buckets_GetItemIndex(grBindsHandle_t)];
+	auto b = Buckets_GetBucketIndex(grBindsHandle_t);
+	auto i = Buckets_GetItemIndex(grBindsHandle_t);
+	return &Comp_GrBinds_BucketContainer.buckets[b].compGrBinds[i];
 }
 
 uint64_t ECS_GetGrBinds_BucketCount() {
 	return Comp_GrBinds_BucketContainer.bucketCounter;
 }
 
-GrBindsComp *ECS_GetGrBinds(uint64_t bucketIndex, uint64_t &itemCount) {
+CompGrBinds *ECS_GetGrBinds(uint64_t bucketIndex, uint64_t &itemCount) {
 	if (bucketIndex == Comp_GrBinds_BucketContainer.bucketCounter) {
 		itemCount = Comp_GrBinds_BucketContainer.itemCounter;
 	} else {
@@ -111,3 +122,45 @@ GrBindsComp *ECS_GetGrBinds(uint64_t bucketIndex, uint64_t &itemCount) {
 	}
 	return Comp_GrBinds_BucketContainer.buckets[bucketIndex].compGrBinds;
 }
+
+CompInstance &ECS_CreateInstance(EntityHandle entHandle) {
+	Entity *ent = nullptr;
+	ECS_GetEntity_Inner(entHandle, ent);
+	InstanceHandle_T newHandle{Buckets_NewHandle(maxBucketItemCount, Comp_Instance_BucketContainer)};
+	ent->instanceHandle = InstanceHandle{newHandle};
+	GrBindsHandle_T grBindsHandle_t{static_cast<GrBindsHandle_T>(ent->grBindsHandle)};
+	assert(grBindsHandle_t != ECS_UNSET_VAL);
+
+	auto b2 = Buckets_GetBucketIndex(grBindsHandle_t);
+	auto i2 = Buckets_GetItemIndex(grBindsHandle_t);
+	auto &grBinds = Comp_GrBinds_BucketContainer.buckets[b2].compGrBinds[i2];
+	auto b = Buckets_GetBucketIndex(newHandle);
+	auto i = Buckets_GetItemIndex(newHandle);
+	auto &comp = Comp_Instance_BucketContainer.buckets[b].instances[i];
+
+	comp.grBindsHandle = ent->grBindsHandle;
+	comp.instanceHandle = ent->instanceHandle;
+	comp.index = grBinds.instances.Count();
+	grBinds.instances.Push({});
+	comp.ptr = &grBinds.instances[comp.index];
+	return comp;
+}
+
+CompInstance *ECS_GetInstance(EntityHandle entHandle) {
+	Entity *ent = nullptr;
+	ECS_GetEntity_Inner(entHandle, ent);
+	GrBindsHandle_T grBindsHandle_t{static_cast<GrBindsHandle_T>(ent->grBindsHandle)};
+	if (grBindsHandle_t == ECS_UNSET_VAL) return nullptr;
+	InstanceHandle_T instanceHandle_t{static_cast<InstanceHandle_T>(ent->instanceHandle)};
+	if (instanceHandle_t == ECS_UNSET_VAL) return nullptr;
+
+	auto b2 = Buckets_GetBucketIndex(grBindsHandle_t);
+	auto i2 = Buckets_GetItemIndex(grBindsHandle_t);
+	auto &grBinds = Comp_GrBinds_BucketContainer.buckets[b2].compGrBinds[i2];
+	auto b = Buckets_GetBucketIndex(instanceHandle_t);
+	auto i = Buckets_GetItemIndex(instanceHandle_t);
+	auto &comp = Comp_Instance_BucketContainer.buckets[b].instances[i];
+
+	comp.ptr = &grBinds.instances[comp.index];
+	return &comp;
+}
diff --git a/src/ecs.hpp b/src/ecs.hpp
index c6cb42b..baebef3 100644
--- a/src/ecs.hpp
+++ b/src/ecs.hpp
@@ -17,12 +17,15 @@ static struct {
 
 void ECS_Init();
 void ECS_Tick(double delta);
-EntityHandle ECS_CreateEntity(EntityHandle parentEntityHandle = EntityHandle{EntityHandle_T{0xFFFFFFFFFFFFFFFF}});
-void ECS_MarkForRemoval(EntityHandle entityHandle);
+EntityHandle ECS_CreateEntity(EntityHandle parentEntHandle = EntityHandle{EntityHandle_T{0xFFFFFFFFFFFFFFFF}});
+void ECS_MarkForRemoval(EntityHandle entHandle);
 
-GrBindsComp &ECS_CreateGrBinds(EntityHandle entHandle);
-GrBindsComp *ECS_GetGrBinds(EntityHandle entHandle);
+CompGrBinds &ECS_CreateGrBinds(EntityHandle entHandle);
+CompGrBinds *ECS_GetGrBinds(EntityHandle entHandle);
 uint64_t ECS_GetGrBinds_BucketCount();
-GrBindsComp *ECS_GetGrBinds(uint64_t bucketIndex, uint64_t &itemCount);
+CompGrBinds *ECS_GetGrBinds(uint64_t bucketIndex, uint64_t &itemCount);
+
+CompInstance &ECS_CreateInstance(EntityHandle entHandle);
+CompInstance *ECS_GetInstance(EntityHandle entHandle);
 
 #endif /* PKE_ECS_HPP */
diff --git a/src/window.cpp b/src/window.cpp
index 54ebbf1..8293c81 100644
--- a/src/window.cpp
+++ b/src/window.cpp
@@ -1001,9 +1001,9 @@ void RecordCommandBuffer(VkCommandBuffer commandBuffer, uint32_t imageIndex) {
 	const uint64_t bindBucketCount = ECS_GetGrBinds_BucketCount();
 	for (long b = 0; b < bindBucketCount; ++b) {
 		uint64_t itemCount;
-		GrBindsComp *items = ECS_GetGrBinds(b, itemCount);
+		CompGrBinds *items = ECS_GetGrBinds(b, itemCount);
 		for (long i = 0; i < itemCount; ++i) {
-			GrBindsComp *binder = &items[i];
+			CompGrBinds *binder = &items[i];
 			vkCmdBindDescriptorSets(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, binder->vkPipelineLayout, 0U, 1U, &binder->vkDescriptorSet, 0, {});
 			vkCmdBindVertexBuffers(commandBuffer, binder->indexFirstBinding, binder->vertexCount, &binder->vertexBuffer, &binder->vertexOffsets);
 			vkCmdBindIndexBuffer(commandBuffer, binder->indexBuffer, binder->vertexOffsets, VK_INDEX_TYPE_UINT16);