Add instance buffer recreation handling in Renderer

This gets windows to run out of the box.

Author: gpx1000

attachments/simple_engine/renderer.h

@@ -827,6 +827,7 @@ class Renderer
 	// Thread-safe: enqueue entities that need GPU-side resource preallocation.
 	// The actual Vulkan work will be performed on the render thread at the frame-start safe point.
 	void EnqueueEntityPreallocationBatch(const std::vector<Entity *> &entities);
+	void EnqueueInstanceBufferRecreation(Entity *entity);
 
 	/**
 	 * @brief Recreate the instance buffer for an entity that had its instances cleared.
@@ -1197,10 +1198,11 @@ class Renderer
 	void ProcessPendingMeshUploads();
 
 	// --- Pending entity GPU preallocation (enqueued by scene loader thread; executed on render thread) ---
-	std::mutex        pendingEntityPreallocMutex;
+	std::mutex            pendingEntityPreallocMutex;
 	std::vector<Entity *> pendingEntityPrealloc;
-	std::atomic<bool> pendingEntityPreallocQueued{false};
-	void              ProcessPendingEntityPreallocations();
+	std::vector<Entity *> pendingInstanceBufferRecreations;
+	std::atomic<bool>     pendingEntityPreallocQueued{false};
+	void                  ProcessPendingEntityPreallocations();
 
 	// Descriptor set layouts (declared before pools and sets)
 	vk::raii::DescriptorSetLayout descriptorSetLayout            = nullptr;

attachments/simple_engine/renderer_resources.cpp

@@ -1772,46 +1772,68 @@ void Renderer::EnqueueEntityPreallocationBatch(const std::vector<Entity *> &enti
 	pendingEntityPreallocQueued.store(true, std::memory_order_relaxed);
 }
 
+void Renderer::EnqueueInstanceBufferRecreation(Entity *entity)
+{
+	if (!entity)
+		return;
+	{
+		std::lock_guard<std::mutex> lk(pendingEntityPreallocMutex);
+		pendingInstanceBufferRecreations.push_back(entity);
+	}
+	pendingEntityPreallocQueued.store(true, std::memory_order_relaxed);
+}
+
 void Renderer::ProcessPendingEntityPreallocations()
 {
 	if (!pendingEntityPreallocQueued.load(std::memory_order_relaxed))
 		return;
 
-	std::vector<Entity *> toProcess;
+	std::vector<Entity *> toPreallocate;
+	std::vector<Entity *> toRecreateInstances;
 	{
 		std::lock_guard<std::mutex> lk(pendingEntityPreallocMutex);
-		if (pendingEntityPrealloc.empty())
+		if (pendingEntityPrealloc.empty() && pendingInstanceBufferRecreations.empty())
 		{
 			pendingEntityPreallocQueued.store(false, std::memory_order_relaxed);
 			return;
 		}
-		toProcess.swap(pendingEntityPrealloc);
+		toPreallocate.swap(pendingEntityPrealloc);
+		toRecreateInstances.swap(pendingInstanceBufferRecreations);
 		pendingEntityPreallocQueued.store(false, std::memory_order_relaxed);
 	}
 
-	// De-dup to avoid repeated work if loader enqueues overlapping batches
-	std::sort(toProcess.begin(), toProcess.end());
-	toProcess.erase(std::unique(toProcess.begin(), toProcess.end()), toProcess.end());
+	// De-dup preallocations
+	std::sort(toPreallocate.begin(), toPreallocate.end());
+	toPreallocate.erase(std::unique(toPreallocate.begin(), toPreallocate.end()), toPreallocate.end());
 
 	std::vector<Entity *> batch;
-	batch.reserve(toProcess.size());
-	for (Entity *e : toProcess)
+	batch.reserve(toPreallocate.size());
+	for (Entity *e : toPreallocate)
 	{
 		if (!e || !e->IsActive())
 			continue;
-		// Only preallocate for entities that actually have renderable mesh data
 		if (!e->GetComponent<MeshComponent>())
 			continue;
 		batch.push_back(e);
 	}
-	if (batch.empty())
-		return;
 
-	// Execute GPU resource creation on the render thread at the safe point.
-	// Keep failures non-fatal so loading can continue; we'll retry on subsequent frames.
-	if (!preAllocateEntityResourcesBatch(batch))
+	if (!batch.empty())
+	{
+		if (!preAllocateEntityResourcesBatch(batch))
+		{
+			std::cerr << "Warning: batch entity GPU preallocation failed; will retry" << std::endl;
+		}
+	}
+
+	// Process instance buffer recreations
+	for (Entity *e : toRecreateInstances)
 	{
-		std::cerr << "Warning: batch entity GPU preallocation failed; will retry" << std::endl;
+		if (!e || !e->IsActive())
+			continue;
+		if (!recreateInstanceBuffer(e))
+		{
+			std::cerr << "Warning: failed to recreate instance buffer for entity " << e->GetName() << std::endl;
+		}
 	}
 }
 

attachments/simple_engine/scene_loading.cpp

@@ -496,9 +496,9 @@ bool LoadGLTFModel(Engine *engine, const std::string &modelPath,
 
 							// Recreate the GPU instance buffer with a single identity instance
 							// The old buffer still had multiple instances, so we need to update it
-							if (renderer && !renderer->recreateInstanceBuffer(nodeEntity))
+							if (renderer)
 							{
-								std::cerr << "[Animation] Failed to recreate instance buffer for reused entity" << std::endl;
+								renderer->EnqueueInstanceBufferRecreation(nodeEntity);
 							}
 						}
 					}
@@ -546,9 +546,9 @@ bool LoadGLTFModel(Engine *engine, const std::string &modelPath,
 							}
 
 							// Pre-allocate resources for this new entity
-							if (renderer && !renderer->preAllocateEntityResources(nodeEntity))
+							if (renderer)
 							{
-								std::cerr << "[Animation] Failed to pre-allocate resources for " << entityName << std::endl;
+								renderer->EnqueueEntityPreallocationBatch({nodeEntity});
 							}
 
 							std::cout << "[Animation] Created new entity '" << entityName << "' for node " << nodeIndex << std::endl;