Fixing synchronization problem between descriptor sets and command buffers

src/Engine/Graphics/Graphics.h

@@ -36,7 +36,7 @@ public:
     virtual void executeCommands(Array<PRenderCommand> commands) = 0;
 
     virtual PTexture2D createTexture2D(const TextureCreateInfo &createInfo) = 0;
-    virtual PUniformBuffer createUniformBuffer(const BulkResourceData &bulkData) = 0;
+    virtual PUniformBuffer createUniformBuffer(const UniformBufferCreateInfo &bulkData) = 0;
     virtual PStructuredBuffer createStructuredBuffer(const BulkResourceData &bulkData) = 0;
     virtual PVertexBuffer createVertexBuffer(const VertexBufferCreateInfo &bulkData) = 0;
     virtual PIndexBuffer createIndexBuffer(const IndexBufferCreateInfo &bulkData) = 0;

src/Engine/Graphics/GraphicsEnums.h

@@ -129,7 +129,19 @@ enum class KeyCode
     KEY_MENU               = 348,
 };
 
-enum class KeyAction
+enum class MouseButton
+{
+    MOUSE_BUTTON_1         = 0,
+    MOUSE_BUTTON_2         = 1,
+    MOUSE_BUTTON_3         = 2,
+    MOUSE_BUTTON_4         = 3,
+    MOUSE_BUTTON_5         = 4,
+    MOUSE_BUTTON_6         = 5,
+    MOUSE_BUTTON_7         = 6,
+    MOUSE_BUTTON_8         = 7,
+};
+
+enum class InputAction
 {
     RELEASE                = 0,
     PRESS                  = 1,
@@ -151,7 +163,7 @@ namespace Gfx
 {
 static constexpr bool useAsyncCompute = true;
 static constexpr bool waitIdleOnSubmit = false;
-static constexpr uint32 numFramesBuffered = 3;
+static constexpr uint32 numFramesBuffered = 8;
 static uint32 currentFrameIndex = 0;
 
 enum class MaterialShadingModel

src/Engine/Graphics/GraphicsInitializer.h

@@ -97,6 +97,15 @@ struct IndexBufferCreateInfo
     {
     }
 };
+struct UniformBufferCreateInfo
+{
+    BulkResourceData resourceData;
+    uint8 bDynamic : 1;
+    UniformBufferCreateInfo()
+        : resourceData(), bDynamic(0)
+    {
+    }
+};
 struct ShaderCreateInfo
 {
     //It's possible to input multiple source files for materials or vertexFactories

src/Engine/Graphics/GraphicsResources.h

@@ -499,7 +499,9 @@ public:
 	virtual void endFrame() = 0;
 	virtual void onWindowCloseEvent() = 0;
 	virtual PTexture2D getBackBuffer() = 0;
-	virtual void setKeyCallback(std::function<void(KeyCode, KeyAction, KeyModifier)> callback) = 0;
+	virtual void setKeyCallback(std::function<void(KeyCode, InputAction, KeyModifier)> callback) = 0;
+	virtual void setMouseMoveCallback(std::function<void(double, double)> callback) = 0;
+	virtual void setMouseButtonCallback(std::function<void(MouseButton, InputAction, KeyModifier)> callback) = 0;
 	SeFormat getSwapchainFormat() const
 	{
 		return pixelFormat;

src/Engine/Graphics/RenderPass/BasePass.cpp

@@ -110,14 +110,15 @@ BasePass::BasePass(const PScene scene, Gfx::PGraphics graphics, Gfx::PViewport v
     Gfx::PRenderTargetLayout layout = new Gfx::RenderTargetLayout(colorAttachment, depthAttachment);
     renderPass = graphics->createRenderPass(layout);
 
-    BulkResourceData uniformInitializer;
+    UniformBufferCreateInfo uniformInitializer;
 
     basePassLayout = graphics->createPipelineLayout();
 
     lightLayout = graphics->createDescriptorLayout();
     lightLayout->addDescriptorBinding(0, Gfx::SE_DESCRIPTOR_TYPE_UNIFORM_BUFFER);
-    uniformInitializer.size = sizeof(LightEnv);
-    uniformInitializer.data = (uint8*)&scene->getLightEnvironment();
+    uniformInitializer.resourceData.size = sizeof(LightEnv);
+    uniformInitializer.resourceData.data = (uint8*)&scene->getLightEnvironment();
+    uniformInitializer.bDynamic = true;
     lightUniform = graphics->createUniformBuffer(uniformInitializer);
     lightLayout->create();
     basePassLayout->addDescriptorLayout(0, lightLayout);
@@ -125,12 +126,14 @@ BasePass::BasePass(const PScene scene, Gfx::PGraphics graphics, Gfx::PViewport v
 
     viewLayout = graphics->createDescriptorLayout();
     viewLayout->addDescriptorBinding(0, Gfx::SE_DESCRIPTOR_TYPE_UNIFORM_BUFFER);
-    uniformInitializer.size = sizeof(ViewParameter);
-    uniformInitializer.data = (uint8*)&viewParams;
+    uniformInitializer.resourceData.size = sizeof(ViewParameter);
+    uniformInitializer.resourceData.data = (uint8*)&viewParams;
+    uniformInitializer.bDynamic = true;
     viewParamBuffer = graphics->createUniformBuffer(uniformInitializer);
     viewLayout->addDescriptorBinding(1, Gfx::SE_DESCRIPTOR_TYPE_UNIFORM_BUFFER);
-    uniformInitializer.size = sizeof(ScreenToViewParameter);
-    uniformInitializer.data = (uint8*)&screenToViewParams;
+    uniformInitializer.resourceData.size = sizeof(ScreenToViewParameter);
+    uniformInitializer.resourceData.data = (uint8*)&screenToViewParams;
+    uniformInitializer.bDynamic = true;
     screenToViewParamBuffer = graphics->createUniformBuffer(uniformInitializer);
     viewLayout->create();
     basePassLayout->addDescriptorLayout(1, viewLayout);

src/Engine/Graphics/SceneView.cpp

@@ -21,7 +21,20 @@ Seele::SceneView::~SceneView()
 {
 }
 
-void SceneView::keyCallback(KeyCode code, KeyAction action, KeyModifier modifier)
+void SceneView::keyCallback(KeyCode code, InputAction action, KeyModifier modifier)
+{
+}
+
+void SceneView::mouseMoveCallback(double xPos, double yPos) 
+{
+	static double prevXPos = 0.0f, prevYPos = 0.0f;
+	double deltaX = xPos - prevXPos;
+	double deltaY = yPos - prevYPos;
+	prevXPos = xPos;
+	prevYPos = yPos;
+	activeCamera->getCameraComponent()->mouseMove(deltaX, deltaY);
+}
+
+void SceneView::mouseButtonCallback(MouseButton button, InputAction action, KeyModifier modifier) 
 {
-	activeCamera->getCameraComponent()->moveOrigin(1);
 }

src/Engine/Graphics/SceneView.h

@@ -13,7 +13,9 @@ public:
 private:
 	PScene scene;
 	PCameraActor activeCamera;
-	virtual void keyCallback(KeyCode code, KeyAction action, KeyModifier modifier) override;
+	virtual void keyCallback(KeyCode code, InputAction action, KeyModifier modifier) override;
+	virtual void mouseMoveCallback(double xPos, double yPos) override;
+	virtual void mouseButtonCallback(MouseButton button, InputAction action, KeyModifier modifier) override;
 };
 DEFINE_REF(SceneView);
 } // namespace Seele

src/Engine/Graphics/View.h

@@ -21,7 +21,9 @@ protected:
 	PWindow owner;
 	PRenderPath renderer;
 
-	virtual void keyCallback(KeyCode code, KeyAction action, KeyModifier modifier) = 0;
+	virtual void keyCallback(KeyCode code, InputAction action, KeyModifier modifier) = 0;
+	virtual void mouseMoveCallback(double xPos, double yPos) = 0;
+	virtual void mouseButtonCallback(MouseButton button, InputAction action, KeyModifier modifier) = 0;
 	friend class Window;
 };
 

src/Engine/Graphics/Vulkan/VulkanBuffer.cpp

@@ -241,14 +241,19 @@ void ShaderBuffer::unlock()
 	}
 }
 
-UniformBuffer::UniformBuffer(PGraphics graphics, const BulkResourceData &resourceData)
-	: Vulkan::ShaderBuffer(graphics, resourceData.size, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, resourceData.owner)
-	, Gfx::UniformBuffer(graphics->getFamilyMapping(), resourceData)
+UniformBuffer::UniformBuffer(PGraphics graphics, const UniformBufferCreateInfo &createInfo)
+	: Vulkan::ShaderBuffer(graphics, createInfo.resourceData.size, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, createInfo.resourceData.owner)
+	, Gfx::UniformBuffer(graphics->getFamilyMapping(), createInfo.resourceData)
+	, dedicatedStagingBuffer(nullptr)
 {
-	if (resourceData.data != nullptr)
+	if(createInfo.bDynamic)
+	{
+		dedicatedStagingBuffer = graphics->getStagingManager()->allocateStagingBuffer(createInfo.resourceData.size, VK_BUFFER_USAGE_TRANSFER_SRC_BIT);
+	}
+	if (createInfo.resourceData.data != nullptr)
 	{
 		void *data = lock();
-		std::memcpy(data, resourceData.data, resourceData.size);
+		std::memcpy(data, createInfo.resourceData.data, createInfo.resourceData.size);
 		unlock();
 	}
 }
@@ -257,6 +262,35 @@ UniformBuffer::~UniformBuffer()
 {
 }
 
+void* UniformBuffer::lock(bool bWriteOnly)
+{
+	if(dedicatedStagingBuffer != nullptr)
+	{
+		return dedicatedStagingBuffer->getMappedPointer();
+	}
+	return ShaderBuffer::lock(bWriteOnly);
+}
+
+void UniformBuffer::unlock()
+{
+	if(dedicatedStagingBuffer != nullptr)
+	{
+		dedicatedStagingBuffer->flushMappedMemory();
+		PCmdBuffer cmdBuffer = graphics->getQueueCommands(ShaderBuffer::currentOwner)->getCommands();
+		VkCommandBuffer cmdHandle = cmdBuffer->getHandle();
+
+		VkBufferCopy region;
+		std::memset(&region, 0, sizeof(VkBufferCopy));
+		region.size = ShaderBuffer::size;
+		vkCmdCopyBuffer(cmdHandle, dedicatedStagingBuffer->getHandle(), buffers[currentBuffer].buffer, 1, &region);
+		graphics->getQueueCommands(ShaderBuffer::currentOwner)->submitCommands();
+	}
+	else
+	{
+		ShaderBuffer::unlock();
+	}
+}
+
 void UniformBuffer::requestOwnershipTransfer(Gfx::QueueType newOwner)
 {
 	Gfx::QueueOwnedResource::transferOwnership(newOwner);

src/Engine/Graphics/Vulkan/VulkanCommandBuffer.cpp

@@ -80,13 +80,16 @@ void CmdBuffer::endRenderPass()
     state = State::InsideBegin;
 }
 
-void CmdBuffer::executeCommands(Array<PSecondaryCmdBuffer> commands)
+void CmdBuffer::executeCommands(Array<Gfx::PRenderCommand> commands)
 {
     assert(state == State::RenderPassActive);
     Array<VkCommandBuffer> cmdBuffers(commands.size());
     for (uint32 i = 0; i < commands.size(); ++i)
     {
-        cmdBuffers[i] = commands[i]->getHandle();
+        auto command = commands[i].cast<SecondaryCmdBuffer>();
+        command->end();
+        executingCommands.add(command);
+        cmdBuffers[i] = command->getHandle();
     }
     vkCmdExecuteCommands(handle, cmdBuffers.size(), cmdBuffers.data());
 }
@@ -105,6 +108,10 @@ void CmdBuffer::refreshFence()
         {
             state = State::ReadyBegin;
             vkResetCommandBuffer(handle, VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT);
+            for(auto command : executingCommands)
+            {
+                command->reset();
+            }
 
             fence->reset();
         }
@@ -159,6 +166,14 @@ void SecondaryCmdBuffer::end()
     VK_CHECK(vkEndCommandBuffer(handle));
 }
 
+void SecondaryCmdBuffer::reset() 
+{
+    for(auto descriptor : boundDescriptors)
+    {
+        descriptor->releaseFromCmd();
+    }
+}
+
 void SecondaryCmdBuffer::begin()
 {
     begin(graphics->getGraphicsCommands()->getCommands());
@@ -179,7 +194,9 @@ void SecondaryCmdBuffer::bindPipeline(Gfx::PGraphicsPipeline gfxPipeline)
 }
 void SecondaryCmdBuffer::bindDescriptor(Gfx::PDescriptorSet descriptorSet)
 {
-    VkDescriptorSet setHandle = descriptorSet.cast<DescriptorSet>()->getHandle();
+    auto descriptor = descriptorSet.cast<DescriptorSet>();
+    boundDescriptors.add(descriptor);
+    VkDescriptorSet setHandle = descriptor->getHandle();
     vkCmdBindDescriptorSets(handle, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline->getLayout(), descriptorSet->getSetIndex(), 1, &setHandle, 0, nullptr);
 }
 void SecondaryCmdBuffer::bindDescriptor(const Array<Gfx::PDescriptorSet>& descriptorSets)
@@ -188,6 +205,7 @@ void SecondaryCmdBuffer::bindDescriptor(const Array<Gfx::PDescriptorSet>& descri
     for(uint32 i = 0; i < descriptorSets.size(); ++i)
     {
         auto descriptorSet = descriptorSets[i].cast<DescriptorSet>();
+        boundDescriptors.add(descriptorSet);
         sets[descriptorSet->getSetIndex()] = descriptorSet->getHandle();
     }
     vkCmdBindDescriptorSets(handle, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline->getLayout(), 0, descriptorSets.size(), sets, 0, nullptr);

src/Engine/Graphics/Vulkan/VulkanCommandBuffer.h

@@ -40,7 +40,7 @@ public:
 	void end();
 	void beginRenderPass(PRenderPass renderPass, PFramebuffer framebuffer);
 	void endRenderPass();
-	void executeCommands(Array<PSecondaryCmdBuffer> secondaryCommands);
+	void executeCommands(Array<Gfx::PRenderCommand> secondaryCommands);
 	void addWaitSemaphore(VkPipelineStageFlags stages, PSemaphore waitSemaphore);
 	void refreshFence();
 	PFence getFence();
@@ -63,6 +63,7 @@ private:
 	State state;
 	Array<PSemaphore> waitSemaphores;
 	Array<VkPipelineStageFlags> waitFlags;
+	Array<PSecondaryCmdBuffer> executingCommands;
 	friend class SecondaryCmdBuffer;
 	friend class CommandBufferManager;
 	friend class Queue;
@@ -70,6 +71,7 @@ private:
 DEFINE_REF(CmdBuffer);
 
 DECLARE_REF(GraphicsPipeline);
+DECLARE_REF(DescriptorSet);
 class SecondaryCmdBuffer : public Gfx::RenderCommand, public CmdBufferBase
 {
 public:
@@ -77,6 +79,7 @@ public:
 	virtual ~SecondaryCmdBuffer();
 	void begin(PCmdBuffer parent);
 	void end();
+	void reset();
 	virtual void begin() override;
 	virtual void setViewport(Gfx::PViewport viewport) override;
 	virtual void bindPipeline(Gfx::PGraphicsPipeline pipeline) override;
@@ -88,6 +91,7 @@ public:
 
 private:
 	PGraphicsPipeline pipeline;
+	Array<PDescriptorSet> boundDescriptors;
 };
 DEFINE_REF(SecondaryCmdBuffer);
 

src/Engine/Graphics/Vulkan/VulkanDescriptorSets.cpp

@@ -3,6 +3,7 @@
 #include "VulkanGraphicsEnums.h"
 #include "VulkanGraphics.h"
 #include "VulkanInitializer.h"
+#include "VulkanCommandBuffer.h"
 
 using namespace Seele;
 using namespace Seele::Vulkan;
@@ -204,6 +205,10 @@ void DescriptorSet::writeChanges()
 {
 	if (writeDescriptors.size() > 0)
 	{
+		if(currentlyBound != nullptr)
+		{
+			currentlyBound->getManager()->waitForCommands(currentlyBound);
+		}
 		vkUpdateDescriptorSets(graphics->getDevice(), writeDescriptors.size(), writeDescriptors.data(), 0, nullptr);
 		writeDescriptors.clear();
 		imageInfos.clear();

src/Engine/Graphics/Vulkan/VulkanDescriptorSets.h

@@ -93,6 +93,14 @@ public:
 	virtual void updateSampler(uint32_t binding, Gfx::PSamplerState samplerState);
 	virtual void updateTexture(uint32_t binding, Gfx::PTexture texture, Gfx::PSamplerState sampler = nullptr);
 	virtual bool operator<(Gfx::PDescriptorSet other);
+	void setCurrentlyBound(PCmdBuffer boundBy)
+	{
+		currentlyBound = boundBy;
+	}
+	void releaseFromCmd()
+	{
+		currentlyBound = nullptr;
+	}
 	inline VkDescriptorSet getHandle() const
 	{
 		return setHandle[Gfx::currentFrameIndex];
@@ -112,6 +120,7 @@ private:
 	Array<void*> cachedData[Gfx::numFramesBuffered];
 	VkDescriptorSet setHandle[Gfx::numFramesBuffered];
 	PDescriptorAllocator owner;
+	PCmdBuffer currentlyBound;
 	PGraphics graphics;
 	friend class DescriptorAllocator;
 };

src/Engine/Graphics/Vulkan/VulkanGraphics.cpp

@@ -82,14 +82,7 @@ void Graphics::endRenderPass()
 
 void Graphics::executeCommands(Array<Gfx::PRenderCommand> commands)
 {
-	Array<VkCommandBuffer> cmdBuffers(commands.size());
-	for (uint32 i = 0; i < commands.size(); ++i)
-	{
-		PSecondaryCmdBuffer buf = commands[i].cast<SecondaryCmdBuffer>();
-		buf->end();
-		cmdBuffers[i] = buf->getHandle();
-	}
-	vkCmdExecuteCommands(getGraphicsCommands()->getCommands()->getHandle(), cmdBuffers.size(), cmdBuffers.data());
+	getGraphicsCommands()->getCommands()->executeCommands(commands);
 }
 
 Gfx::PTexture2D Graphics::createTexture2D(const TextureCreateInfo &createInfo)
@@ -98,7 +91,7 @@ Gfx::PTexture2D Graphics::createTexture2D(const TextureCreateInfo &createInfo)
 	return result;
 }
 
-Gfx::PUniformBuffer Graphics::createUniformBuffer(const BulkResourceData &bulkData)
+Gfx::PUniformBuffer Graphics::createUniformBuffer(const UniformBufferCreateInfo &bulkData)
 {
 	PUniformBuffer uniformBuffer = new UniformBuffer(this, bulkData);
 	return uniformBuffer;

src/Engine/Graphics/Vulkan/VulkanGraphics.h

@@ -48,7 +48,7 @@ public:
 	virtual void executeCommands(Array<Gfx::PRenderCommand> commands) override;
 
 	virtual Gfx::PTexture2D createTexture2D(const TextureCreateInfo &createInfo) override;
-	virtual Gfx::PUniformBuffer createUniformBuffer(const BulkResourceData &bulkData) override;
+	virtual Gfx::PUniformBuffer createUniformBuffer(const UniformBufferCreateInfo &bulkData) override;
 	virtual Gfx::PStructuredBuffer createStructuredBuffer(const BulkResourceData &bulkData) override;
 	virtual Gfx::PVertexBuffer createVertexBuffer(const VertexBufferCreateInfo &bulkData) override;
 	virtual Gfx::PIndexBuffer createIndexBuffer(const IndexBufferCreateInfo &bulkData) override;

src/Engine/Graphics/Vulkan/VulkanGraphicsResources.h

@@ -103,8 +103,8 @@ public:
 	{
 		currentBuffer = (currentBuffer + 1) % numBuffers;
 	}
-	void *lock(bool bWriteOnly = true);
-	void unlock();
+	virtual void *lock(bool bWriteOnly = true);
+	virtual void unlock();
 
 protected:
 	struct BufferAllocation
@@ -127,12 +127,16 @@ protected:
 };
 DEFINE_REF(ShaderBuffer);
 
+DECLARE_REF(StagingBuffer);
 class UniformBuffer : public Gfx::UniformBuffer, public ShaderBuffer
 {
 public:
-	UniformBuffer(PGraphics graphics, const BulkResourceData &resourceData);
+	UniformBuffer(PGraphics graphics, const UniformBufferCreateInfo &resourceData);
 	virtual ~UniformBuffer();
 	virtual void updateContents(const BulkResourceData &resourceData);
+	
+	virtual void* lock(bool bWriteOnly = true) override;
+	virtual void unlock() override;
 protected:
 	// Inherited via Vulkan::Buffer
 	virtual void requestOwnershipTransfer(Gfx::QueueType newOwner);
@@ -140,6 +144,8 @@ protected:
 	virtual VkAccessFlags getDestAccessMask();
 	// Inherited via QueueOwnedResource
 	virtual void executeOwnershipBarrier(Gfx::QueueType newOwner);
+private:
+	PStagingBuffer dedicatedStagingBuffer;
 };
 DEFINE_REF(UniformBuffer);
 
@@ -315,9 +321,13 @@ public:
 	virtual void endFrame() override;
 	virtual Gfx::PTexture2D getBackBuffer() override;
 	virtual void onWindowCloseEvent() override;
-	virtual void setKeyCallback(std::function<void(KeyCode, KeyAction, KeyModifier)> callback) override;
+	virtual void setKeyCallback(std::function<void(KeyCode, InputAction, KeyModifier)> callback) override;
+	virtual void setMouseMoveCallback(std::function<void(double, double)> callback) override;
+	virtual void setMouseButtonCallback(std::function<void(MouseButton, InputAction, KeyModifier)> callback) override;
 
-	std::function<void(KeyCode, KeyAction, KeyModifier)> keyCallback;
+	std::function<void(KeyCode, InputAction, KeyModifier)> keyCallback;
+	std::function<void(double, double)> mouseMoveCallback;
+	std::function<void(MouseButton, InputAction, KeyModifier)> mouseButtonCallback;
 protected:
 	void advanceBackBuffer();
 	void recreateSwapchain(const WindowCreateInfo &createInfo);

src/Engine/Graphics/Vulkan/VulkanInitializer.cpp

@@ -775,10 +775,12 @@ VkBool32 Seele::Vulkan::debugCallback(VkDebugReportFlagsEXT flags, VkDebugReport
 	else
 	{
 		std::cerr << layerPrefix << ": " << msg << std::endl;
+		return VK_FALSE;
 	}
 	return VK_FALSE;
 }
 #pragma warning(default : 4100)
+
 VkResult Seele::Vulkan::CreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackEXT *pCallback)
 {
 	auto func = (PFN_vkCreateDebugReportCallbackEXT)vkGetInstanceProcAddr(instance, "vkCreateDebugReportCallbackEXT");

src/Engine/Graphics/Vulkan/VulkanViewport.cpp

@@ -11,7 +11,7 @@ using namespace Seele::Vulkan;
 void glfwKeyCallback(GLFWwindow* handle, int key, int scancode, int action, int modifier)
 {
     Window* window = (Window*)glfwGetWindowUserPointer(handle);
-    window->keyCallback((KeyCode)key, (KeyAction)action, (KeyModifier)modifier);
+    window->keyCallback((KeyCode)key, (InputAction)action, (KeyModifier)modifier);
 }
 
 Window::Window(PGraphics graphics, const WindowCreateInfo &createInfo)
@@ -76,11 +76,21 @@ Gfx::PTexture2D Window::getBackBuffer()
     return backBufferImages[currentImageIndex];
 }
 
-void Window::setKeyCallback(std::function<void(KeyCode, KeyAction, KeyModifier)> callback)
+void Window::setKeyCallback(std::function<void(KeyCode, InputAction, KeyModifier)> callback)
 {
     keyCallback = callback;
 }
 
+void Window::setMouseMoveCallback(std::function<void(double, double)> callback)
+{
+    mouseMoveCallback = callback;
+}
+
+void Window::setMouseButtonCallback(std::function<void(MouseButton, InputAction, KeyModifier)> callback)
+{
+    mouseButtonCallback = callback;
+}
+
 void Window::advanceBackBuffer()
 {
     VkResult res = VK_ERROR_OUT_OF_DATE_KHR;
@@ -167,6 +177,14 @@ void Window::createSwapchain()
     VK_CHECK(vkGetPhysicalDeviceSurfaceCapabilitiesKHR(graphics->getPhysicalDevice(), surface, &surfProperties));
 
     uint32 desiredNumBuffers = Gfx::numFramesBuffered;
+    if (desiredNumBuffers < surfProperties.minImageCount)
+    {
+        throw new std::logic_error("Trying to buffer less than the minimal number of frames");
+    }
+    if (desiredNumBuffers > surfProperties.maxImageCount)
+    {
+        throw new std::logic_error("Trying to buffer more than the maximum number of frames");
+    }
 
     VkExtent2D extent;
     extent.width = sizeX;

src/Engine/Graphics/WindowManager.cpp

@@ -12,14 +12,14 @@ Seele::WindowManager::WindowManager()
 	info.width = 4096;
 	info.height = 4096;
 	Gfx::PTexture2D testTexture = graphics->createTexture2D(info);
-	BulkResourceData resourceData;
-	resourceData.size = 4096;
-	resourceData.data = new uint8[4096];
+	UniformBufferCreateInfo uniformInitializer;
+	uniformInitializer.resourceData.size = 4096;
+	uniformInitializer.resourceData.data = new uint8[4096];
 	for (int i = 0; i < 4096; ++i)
 	{
-		resourceData.data[i] = (uint8)i;
+		uniformInitializer.resourceData.data[i] = (uint8)i;
 	}
-	Gfx::PUniformBuffer testUniform = graphics->createUniformBuffer(resourceData);
+	Gfx::PUniformBuffer testUniform = graphics->createUniformBuffer(uniformInitializer);
 }
 
 Seele::WindowManager::~WindowManager()

src/Engine/Material/Material.cpp

@@ -120,10 +120,10 @@ void Material::compile()
     if(uniformDataSize != 0)
     {
         uniformData = new uint8[uniformDataSize];
-        BulkResourceData resourceData;
-        resourceData.data = uniformData;
-        resourceData.size = uniformDataSize;
-        uniformBuffer = WindowManager::getGraphics()->createUniformBuffer(resourceData);
+        UniformBufferCreateInfo uniformInitializer;
+        uniformInitializer.resourceData.data = uniformData;
+        uniformInitializer.resourceData.size = uniformDataSize;
+        uniformBuffer = WindowManager::getGraphics()->createUniformBuffer(uniformInitializer);
     }
     layout->create();
     descriptorSet = layout->allocatedDescriptorSet();

src/Engine/Material/MaterialInstance.cpp

@@ -30,10 +30,10 @@ void MaterialInstance::save()
 void MaterialInstance::load() 
 {
     baseMaterial = nullptr; // TODO: actually load the file
-    BulkResourceData resourceData;
-    resourceData.size = baseMaterial->uniformDataSize;
-    resourceData.data = nullptr;
-    uniformBuffer = WindowManager::getGraphics()->createUniformBuffer(resourceData);
+    UniformBufferCreateInfo uniformInitializer;
+    uniformInitializer.resourceData.size = baseMaterial->uniformDataSize;
+    uniformInitializer.resourceData.data = nullptr;
+    uniformBuffer = WindowManager::getGraphics()->createUniformBuffer(uniformInitializer);
     descriptorSet = baseMaterial->layout->allocatedDescriptorSet();
 }
 

src/Engine/Scene/Actor/Actor.cpp

@@ -105,3 +105,8 @@ void Actor::setRootComponent(PComponent newRoot)
     rootComponent = newRoot;
     rootComponent->owner = this;
 }
+
+Transform Actor::getTransform() const
+{
+    return rootComponent->getTransform();
+}

src/Engine/Scene/Actor/Actor.h

@@ -38,6 +38,9 @@ public:
     PComponent getRootComponent();
     void setRootComponent(PComponent newRoot);
 
+    // Returns a read-only copy of the actors transform
+    Transform getTransform() const;
+
 protected:
     void setParent(PActor parent);
     PScene owningScene;

src/Engine/Scene/Scene.cpp

@@ -39,10 +39,11 @@ void Scene::addPrimitiveComponent(PPrimitiveComponent comp)
         data.actorWorldPosition = Vector4(comp->getTransform().getPosition(), 1);
         data.localToWorld = comp->getRenderMatrix();
         data.worldToLocal = glm::inverse(data.localToWorld);
-        BulkResourceData createInfo;
-        createInfo.data = reinterpret_cast<uint8*>(&data);
-        createInfo.owner = Gfx::QueueType::GRAPHICS;
-        createInfo.size = sizeof(data);
+        UniformBufferCreateInfo createInfo;
+        createInfo.resourceData.data = reinterpret_cast<uint8*>(&data);
+        createInfo.resourceData.owner = Gfx::QueueType::GRAPHICS;
+        createInfo.resourceData.size = sizeof(data);
+        createInfo.bDynamic = true;
         Gfx::PUniformBuffer uniformBuffer = graphics->createUniformBuffer(createInfo);
         for(auto& element : batch.elements)
         {