Merge pull request #10 from codingminecraft/multiplayer

Update to PreRelease 0.6

Author: codingminecraft

.gitmodules

@@ -4,9 +4,6 @@
 [submodule "Minecraft/vendor/yamlCpp"]
 	path = Minecraft/vendor/yamlCpp
 	url = https://github.com/jbeder/yaml-cpp
-[submodule "Minecraft/vendor/simplex"]
-	path = Minecraft/vendor/simplex
-	url = https://github.com/SRombauts/SimplexNoise
 [submodule "Minecraft/vendor/cppUtils"]
 	path = Minecraft/vendor/cppUtils
 	url = https://github.com/ambrosiogabe/CppUtils
@@ -25,3 +22,6 @@
 [submodule "Minecraft/vendor/enet"]
 	path = Minecraft/vendor/enet
 	url = https://github.com/lsalzman/enet
+[submodule "Minecraft/vendor/FastNoiseLite"]
+	path = Minecraft/vendor/FastNoiseLite
+	url = https://github.com/Auburn/FastNoiseLite

Minecraft/include/core.h

@@ -10,6 +10,7 @@
 #include <glm/vec4.hpp>
 #include <glm/mat4x4.hpp>
 #include <glm/gtc/type_ptr.hpp>
+#include <glm/gtc/integer.hpp>
 #include <glm/gtx/string_cast.hpp>
 #include <glm/gtx/norm.hpp>
 #include <glm/gtx/rotate_vector.hpp>
@@ -50,12 +51,13 @@
 // stb
 #include <stb/stb_image.h>
 #include <stb/stb_write.h>
+#include <stb/stb_image_resize.h>
 
 // Yaml
 #include <yaml-cpp/yaml.h>
 
-// Simplex 
-#include <SimplexNoise.h>
+// Fast Noise 
+#include <FastNoiseLite.h>
 
 // Freetype
 #include <freetype/freetype.h>
@@ -64,11 +66,42 @@
 #include <magic_enum.hpp>
 
 // Optick
-//#define OPTICK_ENABLE_GPU_D3D12 0
-//#define OPTICK_ENABLE_GPU_VULKAN 0
-//#include <optick.h>
+#ifdef _USE_OPTICK
+#define OPTICK_ENABLE_GPU_D3D12 0
+#define OPTICK_ENABLE_GPU_VULKAN 0
+#include <optick.h>
+#endif
 
 // User defined literals
 glm::vec4 operator""_hex(const char* hexColor, size_t length);
 
+struct RawMemory
+{
+	uint8* data;
+	size_t size;
+	size_t offset;
+
+	void init(size_t initialSize);
+	void free();
+	void shrinkToFit();
+	void resetReadWriteCursor();
+
+	void writeDangerous(const uint8* data, size_t dataSize);
+	void readDangerous(uint8* data, size_t dataSize);
+
+	template<typename T>
+	void write(const T* data)
+	{
+		writeDangerous((uint8*)data, sizeof(T));
+	}
+
+	template<typename T>
+	void read(T* data)
+	{
+		readDangerous((uint8*)data, sizeof(T));
+	}
+
+	void setCursor(size_t offset);
+};
+
 #endif

Minecraft/include/core/Application.h

@@ -6,6 +6,7 @@ namespace Minecraft
 {
 	struct Window;
 	struct Framebuffer;
+	class GlobalThreadPool;
 
 	namespace Application
 	{
@@ -16,8 +17,10 @@ namespace Minecraft
 		void takeScreenshot(const char* filename = "", bool mustBeSquare = false);
 
 		Window& getWindow();
-
 		Framebuffer& getMainFramebuffer();
+		GlobalThreadPool& getGlobalThreadPool();
+
+		extern float deltaTime;
 	}
 }
 

Minecraft/include/core/Components.h

@@ -8,7 +8,10 @@ namespace Minecraft
 	{
 		None,
 		Player,
-		Camera
+		Camera,
+
+		// TODO: Temporary remove this
+		RandomEntity,
 	};
 
 	struct Tag

Minecraft/include/core/Ecs.h

@@ -82,7 +82,7 @@ namespace Minecraft
 					return (index / sparseSetPoolSize) * sparseSetPoolSize;
 				}
 
-				inline SparseSetPool* getPool(EntityIndex index)
+				inline SparseSetPool* getPool(EntityIndex index) const
 				{
 					// TODO: Change this to a hashmap or something for O(1) lookup time
 					// For now do a simple linear search through the pools
@@ -101,6 +101,7 @@ namespace Minecraft
 				template<typename T>
 				inline T* get(EntityIndex index)
 				{
+					// TODO: Use the other get function
 					SparseSetPool* pool = getPool(index);
 					if (!pool)
 					{
@@ -113,6 +114,20 @@ namespace Minecraft
 					return (T*)(data + denseArrayIndex * componentSize);
 				}
 
+				inline uint8* get(EntityIndex index)
+				{
+					SparseSetPool* pool = getPool(index);
+					if (!pool)
+					{
+						g_logger_error("Invalid entity '%d' for component '%d'", index, componentId);
+						return nullptr;
+					}
+
+					EntityIndex denseArrayIndex = pool->entities[index - pool->startIndex];
+					g_logger_assert((denseArrayIndex < numComponents&& denseArrayIndex >= 0), "Invalid dense array index.");
+					return (uint8*)(data + denseArrayIndex * componentSize);
+				}
+
 				template<typename T>
 				inline void add(EntityId entity, const T& component)
 				{
@@ -159,6 +174,51 @@ namespace Minecraft
 					numComponents++;
 				}
 
+				inline void add(EntityId entity)
+				{
+					EntityIndex index = getEntityIndex(entity);
+					SparseSetPool* pool = getPool(index);
+					if (!pool)
+					{
+						const int newNumPools = numPools + 1;
+						SparseSetPool* newPools = (SparseSetPool*)g_memory_realloc(pools, newNumPools * sizeof(SparseSetPool));
+						if (!newPools)
+						{
+							g_logger_error("Failed to allocate memory for new sparse set pool for component '%d'", componentId);
+							return;
+						}
+						numPools = newNumPools;
+						pools = newPools;
+						pools[numPools - 1].init();
+						pools[numPools - 1].startIndex = getPoolAlignedIndex(index);
+						pool = &pools[numPools - 1];
+					}
+
+					uint32 nextIndex = numComponents;
+					if (nextIndex >= maxNumComponents)
+					{
+						int newMaxNumComponents = maxNumComponents * 2;
+						char* newComponentMemory = (char*)g_memory_realloc(data, componentSize * newMaxNumComponents);
+						EntityIndex* newEntityMemory = (EntityIndex*)g_memory_realloc(entities, sizeof(EntityIndex) * newMaxNumComponents);
+						if (!newComponentMemory || !newEntityMemory)
+						{
+							// Just free both of the reallocs if it ever fails
+							g_memory_free(newComponentMemory);
+							g_memory_free(newEntityMemory);
+							g_logger_error("Failed to allocate new memory for component pool or entities for component '%d'", componentId);
+							return;
+						}
+						data = newComponentMemory;
+						entities = newEntityMemory;
+						maxNumComponents = newMaxNumComponents;
+					}
+
+					pool->entities[index - pool->startIndex] = nextIndex;
+					g_memory_zeroMem(data + nextIndex * componentSize, componentSize);
+					entities[nextIndex] = index;
+					numComponents++;
+				}
+
 				template<typename T>
 				inline T* addOrGet(EntityId entity)
 				{
@@ -170,7 +230,17 @@ namespace Minecraft
 					return get<T>(Internal::getEntityIndex(entity));
 				}
 
-				inline bool exists(EntityId entity)
+				inline uint8* addOrGet(EntityId entity)
+				{
+					if (!exists(entity))
+					{
+						add(entity);
+					}
+
+					return get(Internal::getEntityIndex(entity));
+				}
+
+				inline bool exists(EntityId entity) const
 				{
 					const EntityIndex index = getEntityIndex(entity);
 					SparseSetPool* pool = getPool(index);
@@ -263,6 +333,7 @@ namespace Minecraft
 			std::vector<EntityId> entities;
 			std::vector<Internal::SparseSet> componentSets;
 			std::vector<EntityIndex> freeEntities;
+			std::vector<std::string> debugComponentNames;
 
 			EntityId createEntity()
 			{
@@ -279,8 +350,14 @@ namespace Minecraft
 				return entities.back();
 			}
 
+			RawMemory serialize();
+
+			void deserialize(RawMemory& memory);
+
 			void free();
 
+			int numComponents(EntityId entity) const;
+
 			void clear()
 			{
 				entities.clear();
@@ -289,28 +366,40 @@ namespace Minecraft
 					set.free();
 				}
 				componentSets.clear();
+				componentSets = std::vector<Internal::SparseSet>();
+				debugComponentNames.clear();
 				freeEntities.clear();
 			}
 
+			template<typename T>
+			void registerComponent(const char* debugName)
+			{
+				int32 compId = Ecs::componentId<T>();
+
+				// TODO: Maybe do something different here?
+				EntityIndex index = 0;
+
+				g_logger_assert(compId == componentSets.size(), "Tried to register component '%s' twice.", debugName);
+				componentSets.emplace_back(Internal::SparseSet::defaultSet<T>(index));
+				g_logger_assert(compId < Internal::MaxNumComponents, "Exceeded the maximum number of components, you can increase this if needed.");
+				debugComponentNames.emplace_back(std::string(debugName));
+			}
+
 			template<typename T>
 			T& addComponent(EntityId id)
 			{
 				int32 componentId = Ecs::componentId<T>();
 				const EntityIndex index = Internal::getEntityIndex(id);
 
-				if (componentSets.size() <= componentId)
-				{
-					componentSets.resize(componentId + 1, Internal::SparseSet::defaultSet<T>(index));
-					g_logger_assert(componentId < Internal::MaxNumComponents, "Exceeded the maximum number of components, you can increase this if needed.");
-				}
+				g_logger_assert(componentId < componentSets.size(), "You need to register all components in the same order *everywhere*. Component '%s' was not registered.", typeid(T).name());
 
 				// Get or add the component at this index
 				T& component = *componentSets[componentId].addOrGet<T>(index);
 
 				return component;
 			}
 
-			bool validEntity(EntityId id)
+			bool validEntity(EntityId id) const
 			{
 				return Internal::getEntityIndex(id) < entities.size() && !isNull(id);
 			}
@@ -321,7 +410,7 @@ namespace Minecraft
 				return hasComponentById(id, componentId<T>());
 			}
 
-			bool hasComponentById(EntityId id, int32 componentId)
+			bool hasComponentById(EntityId id, int32 componentId) const
 			{
 				if (!validEntity(id))
 				{
@@ -331,19 +420,53 @@ namespace Minecraft
 
 				if (componentId >= componentSets.size() || componentId < 0)
 				{
-					g_logger_warning("Tried to check if an entity had component '%d', but a component of type '%d' does not exist in the registry.", componentId, componentId);
+					g_logger_warning("Tried to check if an entity had component '%d', but a component of type '%d' does not exist in the registry which only has '%d' components.", componentId, componentId, componentSets.size());
 					return false;
 				}
 
 				return componentSets[componentId].exists(id);
 			}
 
+			uint8* getComponentById(EntityId id, int32 componentId)
+			{
+				if (!validEntity(id))
+				{
+					g_logger_error("Cannot check if invalid entity %d has a component.", Internal::getEntityIndex(id));
+					return nullptr;
+				}
+
+				if (componentId >= componentSets.size() || componentId < 0)
+				{
+					g_logger_warning("Tried to check if an entity had component '%d', but a component of type '%d' does not exist in the registry.", componentId, componentId);
+					return nullptr;
+				}
+
+				return componentSets[componentId].get(Internal::getEntityIndex(id));
+			}
+
+			uint8* addOrGetComponentById(EntityId id, int32 componentId)
+			{
+				if (!validEntity(id))
+				{
+					g_logger_error("Cannot check if invalid entity %d has a component.", Internal::getEntityIndex(id));
+					return nullptr;
+				}
+
+				if (componentId >= componentSets.size() || componentId < 0)
+				{
+					g_logger_warning("Tried to check if an entity had component '%d', but a component of type '%d' does not exist in the registry.", componentId, componentId);
+					return nullptr;
+				}
+
+				return componentSets[componentId].addOrGet(id);
+			}
+
 			template<typename T>
 			T& getComponent(EntityId id)
 			{
 				const EntityIndex index = Internal::getEntityIndex(id);
 				int32 compId = Ecs::componentId<T>();
-				g_logger_assert(hasComponent<T>(id), "Entity '%d' does not have component '%d'", id, compId);
+				g_logger_assert(hasComponent<T>(id), "Entity '%d' does not have component '%s'", id, debugComponentNames[compId].c_str());
 
 				if (compId >= componentSets.size() || compId < 0)
 				{