Improving Material shader code generation

src/Engine/Graphics/Vulkan/VulkanAllocator.cpp

@@ -114,7 +114,7 @@ PSubAllocation Allocation::getSuballocation(VkDeviceSize requestedSize, VkDevice
 void Allocation::markFree(SubAllocation *allocation)
 {
 	// Dont free if it is already a free allocation, since they also mark themselves on deletion
-	if(freeRanges.find(allocation->allocatedOffset) != nullptr)
+	if (freeRanges.find(allocation->allocatedOffset) != nullptr)
 	{
 		return;
 	}
@@ -286,6 +286,8 @@ void StagingManager::clearPending()
 
 PStagingBuffer StagingManager::allocateStagingBuffer(uint32 size, VkBufferUsageFlags usage, bool bCPURead)
 {
+	
+	std::unique_lock l(lock);
 	for (auto it = freeBuffers.begin(); it != freeBuffers.end(); ++it)
 	{
 		auto freeBuffer = *it;
@@ -296,6 +298,7 @@ PStagingBuffer StagingManager::allocateStagingBuffer(uint32 size, VkBufferUsageF
 			return freeBuffer;
 		}
 	}
+
 	PStagingBuffer stagingBuffer = new StagingBuffer();
 	VkBufferCreateInfo stagingBufferCreateInfo = init::BufferCreateInfo(usage, size);
 	VkDevice vulkanDevice = graphics->getDevice();
@@ -322,11 +325,13 @@ PStagingBuffer StagingManager::allocateStagingBuffer(uint32 size, VkBufferUsageF
 	vkBindBufferMemory(graphics->getDevice(), stagingBuffer->buffer, stagingBuffer->getMemoryHandle(), stagingBuffer->getOffset());
 
 	activeBuffers.add(stagingBuffer.getHandle());
+	
 	return stagingBuffer;
 }
 
 void StagingManager::releaseStagingBuffer(PStagingBuffer buffer)
 {
+	std::unique_lock l(lock);
 	freeBuffers.add(buffer);
 	activeBuffers.remove(activeBuffers.find(buffer.getHandle()));
 }

src/Engine/Graphics/Vulkan/VulkanAllocator.h

@@ -213,6 +213,7 @@ private:
 	PAllocator allocator;
 	Array<PStagingBuffer> freeBuffers;
 	Array<StagingBuffer *> activeBuffers;
+	std::mutex lock;
 };
 DEFINE_REF(StagingManager);
 } // namespace Vulkan

src/Engine/Graphics/Vulkan/VulkanBuffer.cpp

@@ -14,9 +14,9 @@ struct PendingBuffer
 	bool bWriteOnly;
 };
 
-static Map<Buffer *, PendingBuffer> pendingBuffers;
+static Map<ShaderBuffer *, PendingBuffer> pendingBuffers;
 
-Buffer::Buffer(PGraphics graphics, uint32 size, VkBufferUsageFlags usage, Gfx::QueueType queueType)
+ShaderBuffer::ShaderBuffer(PGraphics graphics, uint32 size, VkBufferUsageFlags usage, Gfx::QueueType queueType)
 	: graphics(graphics), currentBuffer(0), size(size), currentOwner(queueType)
 {
 	if (usage & VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT ||
@@ -56,21 +56,22 @@ Buffer::Buffer(PGraphics graphics, uint32 size, VkBufferUsageFlags usage, Gfx::Q
 	info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
 }
 
-Buffer::~Buffer()
+ShaderBuffer::~ShaderBuffer()
 {
-	auto fence = graphics->getQueueCommands(currentOwner)->getCommands()->getFence();
+	auto cmdBuffer = graphics->getQueueCommands(currentOwner)->getCommands();
 	auto &deletionQueue = graphics->getDeletionQueue();
 	VkDevice device = graphics->getDevice();
 	VkBuffer buf[Gfx::numFramesBuffered];
 	for (uint32 i = 0; i < numBuffers; ++i)
 	{
 		buf[i] = buffers[i].buffer;
-		deletionQueue.addPendingDelete(fence, [device, buf, i]() { vkDestroyBuffer(device, buf[i], nullptr); });
+		deletionQueue.addPendingDelete(cmdBuffer, [device, buf, i]() { vkDestroyBuffer(device, buf[i], nullptr); });
 		buffers[i].allocation = nullptr;
 	}
+	graphics = nullptr;
 }
 
-void Buffer::executeOwnershipBarrier(Gfx::QueueType newOwner)
+void ShaderBuffer::executeOwnershipBarrier(Gfx::QueueType newOwner)
 {
 	VkBufferMemoryBarrier barrier =
 		init::BufferMemoryBarrier();
@@ -137,7 +138,7 @@ void Buffer::executeOwnershipBarrier(Gfx::QueueType newOwner)
 	currentOwner = newOwner;
 }
 
-void *Buffer::lock(bool bWriteOnly)
+void *ShaderBuffer::lock(bool bWriteOnly)
 {
 	void *data = nullptr;
 
@@ -208,7 +209,7 @@ void *Buffer::lock(bool bWriteOnly)
 	return data;
 }
 
-void Buffer::unlock()
+void ShaderBuffer::unlock()
 {
 	auto found = pendingBuffers.find(this);
 	if (found != pendingBuffers.end())
@@ -233,8 +234,8 @@ void Buffer::unlock()
 }
 
 UniformBuffer::UniformBuffer(PGraphics graphics, const BulkResourceData &resourceData)
-	: Buffer(graphics, resourceData.size, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, resourceData.owner)
-	, Gfx::UniformBuffer(graphics, resourceData.owner)
+	: Vulkan::ShaderBuffer(graphics, resourceData.size, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, resourceData.owner)
+	, Gfx::UniformBuffer(graphics->getFamilyMapping(), resourceData.owner)
 {
 	if (resourceData.data != nullptr)
 	{
@@ -251,12 +252,12 @@ UniformBuffer::~UniformBuffer()
 void UniformBuffer::requestOwnershipTransfer(Gfx::QueueType newOwner)
 {
 	Gfx::QueueOwnedResource::transferOwnership(newOwner);
-	Buffer::currentOwner = newOwner;
+	Vulkan::ShaderBuffer::currentOwner = newOwner;
 }
 
 void UniformBuffer::executeOwnershipBarrier(Gfx::QueueType newOwner)
 {
-	Buffer::executeOwnershipBarrier(newOwner);
+	Vulkan::ShaderBuffer::executeOwnershipBarrier(newOwner);
 }
 
 VkAccessFlags UniformBuffer::getSourceAccessMask()
@@ -270,8 +271,8 @@ VkAccessFlags UniformBuffer::getDestAccessMask()
 }
 
 StructuredBuffer::StructuredBuffer(PGraphics graphics, const BulkResourceData &resourceData)
-	: Buffer(graphics, resourceData.size, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, resourceData.owner)
-	, Gfx::StructuredBuffer(graphics, resourceData.owner)
+	: Vulkan::ShaderBuffer(graphics, resourceData.size, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, resourceData.owner)
+	, Gfx::StructuredBuffer(graphics->getFamilyMapping(), resourceData.owner)
 {
 	if (resourceData.data != nullptr)
 	{
@@ -292,7 +293,7 @@ void StructuredBuffer::requestOwnershipTransfer(Gfx::QueueType newOwner)
 
 void StructuredBuffer::executeOwnershipBarrier(Gfx::QueueType newOwner)
 {
-	Buffer::executeOwnershipBarrier(newOwner);
+	Vulkan::ShaderBuffer::executeOwnershipBarrier(newOwner);
 }
 
 VkAccessFlags StructuredBuffer::getSourceAccessMask()
@@ -306,8 +307,8 @@ VkAccessFlags StructuredBuffer::getDestAccessMask()
 }
 
 VertexBuffer::VertexBuffer(PGraphics graphics, const VertexBufferCreateInfo &resourceData)
-	: Buffer(graphics, resourceData.resourceData.size, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, resourceData.resourceData.owner)
-	, Gfx::VertexBuffer(graphics, resourceData.numVertices, resourceData.vertexSize, resourceData.resourceData.owner)
+	: Vulkan::ShaderBuffer(graphics, resourceData.resourceData.size, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, resourceData.resourceData.owner)
+	, Gfx::VertexBuffer(graphics->getFamilyMapping(), resourceData.numVertices, resourceData.vertexSize, resourceData.resourceData.owner)
 {
 	if (resourceData.resourceData.data != nullptr)
 	{
@@ -328,7 +329,7 @@ void VertexBuffer::requestOwnershipTransfer(Gfx::QueueType newOwner)
 
 void VertexBuffer::executeOwnershipBarrier(Gfx::QueueType newOwner)
 {
-	Buffer::executeOwnershipBarrier(newOwner);
+	Vulkan::ShaderBuffer::executeOwnershipBarrier(newOwner);
 }
 
 VkAccessFlags VertexBuffer::getSourceAccessMask()
@@ -342,8 +343,8 @@ VkAccessFlags VertexBuffer::getDestAccessMask()
 }
 
 IndexBuffer::IndexBuffer(PGraphics graphics, const IndexBufferCreateInfo &resourceData)
-	: Buffer(graphics, resourceData.resourceData.size, VK_BUFFER_USAGE_INDEX_BUFFER_BIT, resourceData.resourceData.owner)
-	, Gfx::IndexBuffer(graphics, resourceData.resourceData.size, resourceData.indexType, resourceData.resourceData.owner)
+	: Vulkan::ShaderBuffer(graphics, resourceData.resourceData.size, VK_BUFFER_USAGE_INDEX_BUFFER_BIT, resourceData.resourceData.owner)
+	, Gfx::IndexBuffer(graphics->getFamilyMapping(), resourceData.resourceData.size, resourceData.indexType, resourceData.resourceData.owner)
 {
 	if (resourceData.resourceData.data != nullptr)
 	{
@@ -364,7 +365,7 @@ void IndexBuffer::requestOwnershipTransfer(Gfx::QueueType newOwner)
 
 void IndexBuffer::executeOwnershipBarrier(Gfx::QueueType newOwner)
 {
-	Buffer::executeOwnershipBarrier(newOwner);
+	Vulkan::ShaderBuffer::executeOwnershipBarrier(newOwner);
 }
 
 VkAccessFlags IndexBuffer::getSourceAccessMask()

src/Engine/Graphics/Vulkan/VulkanCommandBuffer.cpp

@@ -22,8 +22,8 @@ CmdBufferBase::~CmdBufferBase()
     graphics = nullptr;
 }
 
-CmdBuffer::CmdBuffer(PGraphics graphics, VkCommandPool cmdPool)
-    : CmdBufferBase(graphics, cmdPool), renderPass(nullptr), framebuffer(nullptr), subpassIndex(0)
+CmdBuffer::CmdBuffer(PGraphics graphics, VkCommandPool cmdPool, PCommandBufferManager manager)
+    : CmdBufferBase(graphics, cmdPool), renderPass(nullptr), framebuffer(nullptr), subpassIndex(0), manager(manager)
 {
     VkCommandBufferAllocateInfo allocInfo =
         init::CommandBufferAllocateInfo(cmdPool,
@@ -120,6 +120,11 @@ PFence CmdBuffer::getFence()
     return fence;
 }
 
+PCommandBufferManager CmdBuffer::getManager() 
+{
+    return manager;
+}
+
 SecondaryCmdBuffer::SecondaryCmdBuffer(PGraphics graphics, VkCommandPool cmdPool)
     : CmdBufferBase(graphics, cmdPool)
 {
@@ -195,8 +200,9 @@ CommandBufferManager::CommandBufferManager(PGraphics graphics, PQueue queue)
 
     VK_CHECK(vkCreateCommandPool(graphics->getDevice(), &info, nullptr, &commandPool));
 
-    activeCmdBuffer = new CmdBuffer(graphics, commandPool);
+    activeCmdBuffer = new CmdBuffer(graphics, commandPool, this);
     activeCmdBuffer->begin();
+    std::lock_guard lock(allocatedBufferLock);
     allocatedBuffers.add(activeCmdBuffer);
 }
 
@@ -236,6 +242,7 @@ void CommandBufferManager::submitCommands(PSemaphore signalSemaphore)
             queue->submitCommandBuffer(activeCmdBuffer);
         }
     }
+    std::lock_guard lock(allocatedBufferLock);
     for (uint32 i = 0; i < allocatedBuffers.size(); ++i)
     {
         PCmdBuffer cmdBuffer = allocatedBuffers[i];
@@ -251,7 +258,7 @@ void CommandBufferManager::submitCommands(PSemaphore signalSemaphore)
             assert(cmdBuffer->state == CmdBuffer::State::Submitted);
         }
     }
-    activeCmdBuffer = new CmdBuffer(graphics, commandPool);
+    activeCmdBuffer = new CmdBuffer(graphics, commandPool, this);
     allocatedBuffers.add(activeCmdBuffer);
     activeCmdBuffer->begin();
 }

src/Engine/Graphics/Vulkan/VulkanCommandBuffer.h

@@ -30,10 +30,11 @@ protected:
 DEFINE_REF(CmdBufferBase);
 
 DECLARE_REF(SecondaryCmdBuffer);
+DECLARE_REF(CommandBufferManager);
 class CmdBuffer : public CmdBufferBase
 {
 public:
-	CmdBuffer(PGraphics graphics, VkCommandPool cmdPool);
+	CmdBuffer(PGraphics graphics, VkCommandPool cmdPool, PCommandBufferManager manager);
 	virtual ~CmdBuffer();
 	void begin();
 	void end();
@@ -43,6 +44,7 @@ public:
 	void addWaitSemaphore(VkPipelineStageFlags stages, PSemaphore waitSemaphore);
 	void refreshFence();
 	PFence getFence();
+	PCommandBufferManager getManager();
 	enum State
 	{
 		ReadyBegin,
@@ -53,6 +55,7 @@ public:
 	};
 
 private:
+	PCommandBufferManager manager;
 	PRenderPass renderPass;
 	PFramebuffer framebuffer;
 	PFence fence;
@@ -105,6 +108,7 @@ private:
 	PQueue queue;
 	uint32 queueFamilyIndex;
 	PCmdBuffer activeCmdBuffer;
+	std::mutex allocatedBufferLock;
 	Array<PCmdBuffer> allocatedBuffers;
 };
 DEFINE_REF(CommandBufferManager);

src/Engine/Graphics/Vulkan/VulkanFramebuffer.cpp

@@ -49,4 +49,5 @@ Framebuffer::Framebuffer(PGraphics graphics, PRenderPass renderPass, Gfx::PRende
 Framebuffer::~Framebuffer()
 {
     vkDestroyFramebuffer(graphics->getDevice(), handle, nullptr);
+    graphics = nullptr;
 }

src/Engine/Graphics/Vulkan/VulkanGraphics.cpp

@@ -64,6 +64,7 @@ void Graphics::beginRenderPass(Gfx::PRenderPass renderPass)
 	if (found == allocatedFramebuffers.end())
 	{
 		framebuffer = new Framebuffer(this, rp, rp->getLayout());
+		allocatedFramebuffers[framebufferHash] = framebuffer;
 	}
 	else
 	{

src/Engine/Graphics/Vulkan/VulkanGraphicsResources.cpp

@@ -23,10 +23,10 @@ QueueOwnedResourceDeletion::~QueueOwnedResourceDeletion()
     worker.join();
 }
 
-void QueueOwnedResourceDeletion::addPendingDelete(PFence fence, std::function<void()> func)
+void QueueOwnedResourceDeletion::addPendingDelete(PCmdBuffer cmdbuffer, std::function<void()> func)
 {
     PendingItem item;
-    item.fence = fence;
+    item.cmdBuffer = cmdbuffer;
     item.func = func;
     deletionQueue.add(item);
     std::unique_lock<std::mutex> lock(mutex);
@@ -40,13 +40,12 @@ void QueueOwnedResourceDeletion::run()
         std::unique_lock<std::mutex> lock(mutex);
         cv.wait(lock);
         auto entry = deletionQueue.begin();
-        PFence fence = entry->fence;
-        fence->wait(1000ull);
-        if (fence->isSignaled())
-        {
-            entry->func();
-            deletionQueue.remove(entry);
-        }
+        PCmdBuffer cmdBuffer = entry->cmdBuffer;
+        //cmdBuffer->getManager()->waitForCommands(cmdBuffer);
+        //cmdBuffer->begin();
+
+        //entry->func();
+        deletionQueue.remove(entry);
     }
 }
 

src/Engine/Graphics/Vulkan/VulkanGraphicsResources.h

@@ -10,6 +10,7 @@ namespace Vulkan
 
 DECLARE_REF(DescriptorAllocator);
 DECLARE_REF(CommandBufferManager);
+DECLARE_REF(CmdBuffer);
 DECLARE_REF(Graphics);
 DECLARE_REF(SubAllocation);
 class Semaphore
@@ -57,7 +58,7 @@ class QueueOwnedResourceDeletion
 public:
 	QueueOwnedResourceDeletion();
 	virtual ~QueueOwnedResourceDeletion();
-	static void addPendingDelete(PFence fence, std::function<void()> function);
+	static void addPendingDelete(PCmdBuffer fence, std::function<void()> function);
 
 private:
 	std::thread worker;
@@ -65,7 +66,7 @@ private:
 	static void run();
 	struct PendingItem
 	{
-		PFence fence;
+		PCmdBuffer cmdBuffer;
 		std::function<void()> func;
 	};
 	static std::mutex mutex;
@@ -73,11 +74,11 @@ private:
 	static List<PendingItem> deletionQueue;
 };
 
-class Buffer
+class ShaderBuffer
 {
 public:
-	Buffer(PGraphics graphics, uint32 size, VkBufferUsageFlags usage, Gfx::QueueType queueType);
-	virtual ~Buffer();
+	ShaderBuffer(PGraphics graphics, uint32 size, VkBufferUsageFlags usage, Gfx::QueueType queueType);
+	virtual ~ShaderBuffer();
 	VkBuffer getHandle() const
 	{
 		return buffers[currentBuffer].buffer;
@@ -108,9 +109,9 @@ protected:
 	virtual VkAccessFlags getSourceAccessMask() = 0;
 	virtual VkAccessFlags getDestAccessMask() = 0;
 };
-DEFINE_REF(Buffer);
+DEFINE_REF(ShaderBuffer);
 
-class UniformBuffer : public Buffer, public Gfx::UniformBuffer
+class UniformBuffer : public Gfx::UniformBuffer, public ShaderBuffer
 {
 public:
 	UniformBuffer(PGraphics graphics, const BulkResourceData &resourceData);
@@ -126,7 +127,7 @@ protected:
 };
 DEFINE_REF(UniformBuffer);
 
-class StructuredBuffer : public Buffer, public Gfx::StructuredBuffer
+class StructuredBuffer : public Gfx::StructuredBuffer, public ShaderBuffer
 {
 public:
 	StructuredBuffer(PGraphics graphics, const BulkResourceData &resourceData);
@@ -142,7 +143,7 @@ protected:
 };
 DEFINE_REF(StructuredBuffer);
 
-class VertexBuffer : public Buffer, public Gfx::VertexBuffer
+class VertexBuffer : public Gfx::VertexBuffer, public ShaderBuffer
 {
 public:
 	VertexBuffer(PGraphics graphics, const VertexBufferCreateInfo &resourceData);
@@ -158,7 +159,7 @@ protected:
 };
 DEFINE_REF(VertexBuffer);
 
-class IndexBuffer : public Buffer, public Gfx::IndexBuffer
+class IndexBuffer : public Gfx::IndexBuffer, public ShaderBuffer
 {
 public:
 	IndexBuffer(PGraphics graphics, const IndexBufferCreateInfo &resourceData);
@@ -249,7 +250,7 @@ protected:
 };
 DEFINE_REF(TextureBase);
 
-class Texture2D : public TextureBase, public Gfx::Texture2D
+class Texture2D : public Gfx::Texture2D, public TextureBase
 {
 public:
 	Texture2D(PGraphics graphics, const TextureCreateInfo& createInfo, VkImage existingImage = VK_NULL_HANDLE);

src/Engine/Graphics/Vulkan/VulkanPipelineCache.cpp

@@ -242,7 +242,6 @@ PGraphicsPipeline PipelineCache::createPipeline(const GraphicsPipelineCreateInfo
             0
         );
 
-
     createInfo.pStages = stageInfos;
     createInfo.pVertexInputState = &vertexInput;
     createInfo.pInputAssemblyState = &assemblyInfo;

src/Engine/Graphics/Vulkan/VulkanShader.cpp

@@ -55,7 +55,6 @@ void Shader::create(const ShaderCreateInfo& createInfo)
     int targetIndex = spAddCodeGenTarget(request, SLANG_SPIRV);
     spSetTargetProfile(request, targetIndex, spFindProfile(session, "glsl_vk"));
     spSetDumpIntermediates(request, true);
-
     int translationUnitIndex = spAddTranslationUnit(request, SLANG_SOURCE_LANGUAGE_SLANG, "");
 
     for(auto code : createInfo.shaderCode)
@@ -67,15 +66,20 @@ void Shader::create(const ShaderCreateInfo& createInfo)
             code.data()
         );
     }
+    for(auto define : createInfo.defines)
+    {
+        spAddPreprocessorDefine(request, define.key, define.value);
+    }
     spAddSearchPath(request, "shaders/lib/");
+    spAddSearchPath(request, "shaders/generated/");
 
     spSetGlobalGenericArgs(request, createInfo.typeParameter.size(), createInfo.typeParameter.data());
     
     int entryPointIndex = spAddEntryPoint(request, translationUnitIndex, entryPointName.c_str(), getStageFromShaderType(type));
     if(spCompile(request))
     {
-        char const* diagnostice = spGetDiagnosticOutput(request);
-        std::cout << diagnostice << std::endl;
+        char const* diagnostics = spGetDiagnosticOutput(request);
+        std::cout << diagnostics << std::endl;
     }
 
     ShaderReflection* reflection = slang::ShaderReflection::get(request);

src/Engine/Graphics/Vulkan/VulkanTexture.cpp

@@ -154,12 +154,12 @@ TextureHandle::TextureHandle(PGraphics graphics, VkImageViewType viewType,
 TextureHandle::~TextureHandle()
 {
     auto &deletionQueue = graphics->getDeletionQueue();
-    auto fence = graphics->getQueueCommands(currentOwner)->getCommands()->getFence();
+    auto cmdBuffer = graphics->getQueueCommands(currentOwner)->getCommands();
     VkDevice device = graphics->getDevice();
     VkImageView view = defaultView;
     VkImage img = image;
-    deletionQueue.addPendingDelete(fence, [device, view]() { vkDestroyImageView(device, view, nullptr); });
-    deletionQueue.addPendingDelete(fence, [device, img]() { vkDestroyImage(device, img, nullptr); });
+    deletionQueue.addPendingDelete(cmdBuffer, [device, view]() { vkDestroyImageView(device, view, nullptr); });
+    deletionQueue.addPendingDelete(cmdBuffer, [device, img]() { vkDestroyImage(device, img, nullptr); });
 }
 
 void TextureHandle::changeLayout(VkImageLayout newLayout)
@@ -243,7 +243,7 @@ void TextureBase::changeLayout(VkImageLayout newLayout)
 }
 
 Texture2D::Texture2D(PGraphics graphics, const TextureCreateInfo& createInfo, VkImage existingImage)
-    : Gfx::Texture2D(graphics, createInfo.resourceData.owner)
+    : Gfx::Texture2D(graphics->getFamilyMapping(), createInfo.resourceData.owner)
 {
     textureHandle = new TextureHandle(graphics, createInfo.bArray ? VK_IMAGE_VIEW_TYPE_2D_ARRAY : VK_IMAGE_VIEW_TYPE_2D, 
         createInfo, existingImage);