Moved many Cast functions to libVulkan.cpp

src/Vulkan/VkBuffer.cpp

@@ -68,9 +68,9 @@ const VkMemoryRequirements Buffer::getMemoryRequirements() const
 	return memoryRequirements;
 }
 
-void Buffer::bind(VkDeviceMemory pDeviceMemory, VkDeviceSize pMemoryOffset)
+void Buffer::bind(DeviceMemory* pDeviceMemory, VkDeviceSize pMemoryOffset)
 {
-	memory = Cast(pDeviceMemory)->getOffsetPointer(pMemoryOffset);
+	memory = pDeviceMemory->getOffsetPointer(pMemoryOffset);
 }
 
 void Buffer::copyFrom(const void* srcMemory, VkDeviceSize pSize, VkDeviceSize pOffset)

src/Vulkan/VkBuffer.hpp

@@ -20,6 +20,8 @@
 namespace vk
 {
 
+class DeviceMemory;
+
 class Buffer : public Object<Buffer, VkBuffer>
 {
 public:
@@ -29,7 +31,7 @@ public:
 	static size_t ComputeRequiredAllocationSize(const VkBufferCreateInfo* pCreateInfo);
 
 	const VkMemoryRequirements getMemoryRequirements() const;
-	void bind(VkDeviceMemory pDeviceMemory, VkDeviceSize pMemoryOffset);
+	void bind(DeviceMemory* pDeviceMemory, VkDeviceSize pMemoryOffset);
 	void copyFrom(const void* srcMemory, VkDeviceSize size, VkDeviceSize offset);
 	void copyTo(void* dstMemory, VkDeviceSize size, VkDeviceSize offset) const;
 	void copyTo(Buffer* dstBuffer, const VkBufferCopy& pRegion) const;

src/Vulkan/VkBufferView.cpp

@@ -20,11 +20,11 @@ namespace vk
 {
 
 BufferView::BufferView(const VkBufferViewCreateInfo* pCreateInfo, void* mem) :
-    buffer(pCreateInfo->buffer), format(pCreateInfo->format), offset(pCreateInfo->offset)
+    buffer(Cast(pCreateInfo->buffer)), format(pCreateInfo->format), offset(pCreateInfo->offset)
 {
     if (pCreateInfo->range == VK_WHOLE_SIZE)
     {
-        range = Cast(pCreateInfo->buffer)->getSize() - offset;
+        range = buffer->getSize() - offset;
     }
     else
     {
@@ -34,7 +34,7 @@ BufferView::BufferView(const VkBufferViewCreateInfo* pCreateInfo, void* mem) :
 
 void * BufferView::getPointer() const
 {
-    return Cast(buffer)->getOffsetPointer(offset);
+    return buffer->getOffsetPointer(offset);
 }
 
 }
\ No newline at end of file

src/Vulkan/VkBufferView.hpp

@@ -22,6 +22,8 @@
 namespace vk
 {
 
+class Buffer;
+
 class BufferView : public Object<BufferView, VkBufferView>
 {
 public:
@@ -39,7 +41,7 @@ public:
 
 	const uint32_t id = ImageView::nextID++;	// ID space for sampling function cache, shared with imageviews
 private:
-	VkBuffer     buffer;
+	Buffer      *buffer;
 	VkFormat     format;
 	VkDeviceSize offset;
 	VkDeviceSize range;

src/Vulkan/VkCommandBuffer.hpp

@@ -34,8 +34,12 @@ namespace vk
 {
 
 class Buffer;
+class Event;
 class Framebuffer;
+class Image;
 class Pipeline;
+class PipelineLayout;
+class QueryPool;
 class RenderPass;
 
 class CommandBuffer
@@ -51,7 +55,7 @@ public:
 	VkResult end();
 	VkResult reset(VkCommandPoolResetFlags flags);
 
-	void beginRenderPass(VkRenderPass renderPass, VkFramebuffer framebuffer, VkRect2D renderArea,
+	void beginRenderPass(RenderPass* renderPass, Framebuffer* framebuffer, VkRect2D renderArea,
 	                     uint32_t clearValueCount, const VkClearValue* pClearValues, VkSubpassContents contents);
 	void nextSubpass(VkSubpassContents contents);
 	void endRenderPass();
@@ -65,17 +69,17 @@ public:
 	                     uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers,
 	                     uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers,
 	                     uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers);
-	void bindPipeline(VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline);
+	void bindPipeline(VkPipelineBindPoint pipelineBindPoint, Pipeline* pipeline);
 	void bindVertexBuffers(uint32_t firstBinding, uint32_t bindingCount,
 	                       const VkBuffer* pBuffers, const VkDeviceSize* pOffsets);
 
-	void beginQuery(VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags);
-	void endQuery(VkQueryPool queryPool, uint32_t query);
-	void resetQueryPool(VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount);
-	void writeTimestamp(VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query);
-	void copyQueryPoolResults(VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount,
-	                          VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags);
-	void pushConstants(VkPipelineLayout layout, VkShaderStageFlags stageFlags,
+	void beginQuery(QueryPool* queryPool, uint32_t query, VkQueryControlFlags flags);
+	void endQuery(QueryPool* queryPool, uint32_t query);
+	void resetQueryPool(QueryPool* queryPool, uint32_t firstQuery, uint32_t queryCount);
+	void writeTimestamp(VkPipelineStageFlagBits pipelineStage, QueryPool* queryPool, uint32_t query);
+	void copyQueryPoolResults(const QueryPool* queryPool, uint32_t firstQuery, uint32_t queryCount,
+	                          Buffer* dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags);
+	void pushConstants(PipelineLayout* layout, VkShaderStageFlags stageFlags,
 	                   uint32_t offset, uint32_t size, const void* pValues);
 
 	void setViewport(uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports);
@@ -87,33 +91,33 @@ public:
 	void setStencilCompareMask(VkStencilFaceFlags faceMask, uint32_t compareMask);
 	void setStencilWriteMask(VkStencilFaceFlags faceMask, uint32_t writeMask);
 	void setStencilReference(VkStencilFaceFlags faceMask, uint32_t reference);
-	void bindDescriptorSets(VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout,
+	void bindDescriptorSets(VkPipelineBindPoint pipelineBindPoint, const PipelineLayout* layout,
 		uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets,
 		uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets);
-	void bindIndexBuffer(VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType);
+	void bindIndexBuffer(Buffer* buffer, VkDeviceSize offset, VkIndexType indexType);
 	void dispatch(uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ);
-	void dispatchIndirect(VkBuffer buffer, VkDeviceSize offset);
-	void copyBuffer(VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions);
-	void copyImage(VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout,
+	void dispatchIndirect(Buffer* buffer, VkDeviceSize offset);
+	void copyBuffer(const Buffer* srcBuffer, Buffer* dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions);
+	void copyImage(const Image* srcImage, VkImageLayout srcImageLayout, Image* dstImage, VkImageLayout dstImageLayout,
 		uint32_t regionCount, const VkImageCopy* pRegions);
-	void blitImage(VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout,
+	void blitImage(const Image* srcImage, VkImageLayout srcImageLayout, Image* dstImage, VkImageLayout dstImageLayout,
 		uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter);
-	void copyBufferToImage(VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout,
+	void copyBufferToImage(Buffer* srcBuffer, Image* dstImage, VkImageLayout dstImageLayout,
 		uint32_t regionCount, const VkBufferImageCopy* pRegions);
-	void copyImageToBuffer(VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer,
+	void copyImageToBuffer(Image* srcImage, VkImageLayout srcImageLayout, Buffer* dstBuffer,
 		uint32_t regionCount, const VkBufferImageCopy* pRegions);
-	void updateBuffer(VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData);
-	void fillBuffer(VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data);
-	void clearColorImage(VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor,
+	void updateBuffer(Buffer* dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData);
+	void fillBuffer(Buffer* dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data);
+	void clearColorImage(Image* image, VkImageLayout imageLayout, const VkClearColorValue* pColor,
 		uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
-	void clearDepthStencilImage(VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil,
+	void clearDepthStencilImage(Image* image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil,
 		uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
 	void clearAttachments(uint32_t attachmentCount, const VkClearAttachment* pAttachments,
 		uint32_t rectCount, const VkClearRect* pRects);
-	void resolveImage(VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout,
+	void resolveImage(const Image* srcImage, VkImageLayout srcImageLayout, Image* dstImage, VkImageLayout dstImageLayout,
 		uint32_t regionCount, const VkImageResolve* pRegions);
-	void setEvent(VkEvent event, VkPipelineStageFlags stageMask);
-	void resetEvent(VkEvent event, VkPipelineStageFlags stageMask);
+	void setEvent(Event* event, VkPipelineStageFlags stageMask);
+	void resetEvent(Event* event, VkPipelineStageFlags stageMask);
 	void waitEvents(uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask,
 		VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers,
 		uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers,
@@ -121,8 +125,8 @@ public:
 
 	void draw(uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance);
 	void drawIndexed(uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance);
-	void drawIndirect(VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
-	void drawIndexedIndirect(VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
+	void drawIndirect(Buffer* buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
+	void drawIndexedIndirect(Buffer* buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
 
 	// TODO(sugoi): Move ExecutionState out of CommandBuffer (possibly into Device)
 	struct ExecutionState

src/Vulkan/VkDescriptorPool.cpp

@@ -62,7 +62,7 @@ VkResult DescriptorPool::allocateSets(uint32_t descriptorSetCount, const VkDescr
 	{
 		for(uint32_t i = 0; i < descriptorSetCount; i++)
 		{
-			Cast(pSetLayouts[i])->initialize(pDescriptorSets[i]);
+			Cast(pSetLayouts[i])->initialize(vk::Cast(pDescriptorSets[i]));
 		}
 	}
 	return result;

src/Vulkan/VkDescriptorSetLayout.cpp

@@ -144,10 +144,9 @@ uint32_t DescriptorSetLayout::getBindingIndex(uint32_t binding) const
 	return 0;
 }
 
-void DescriptorSetLayout::initialize(VkDescriptorSet vkDescriptorSet)
+void DescriptorSetLayout::initialize(DescriptorSet* descriptorSet)
 {
 	// Use a pointer to this descriptor set layout as the descriptor set's header
-	DescriptorSet* descriptorSet = vk::Cast(vkDescriptorSet);
 	descriptorSet->header.layout = this;
 	uint8_t* mem = descriptorSet->data;
 

src/Vulkan/VkDescriptorSetLayout.hpp

@@ -84,7 +84,7 @@ public:
 	static void WriteDescriptorSet(DescriptorSet *dstSet, VkDescriptorUpdateTemplateEntry const &entry, char const *src);
 	static void WriteTextureLevelInfo(sw::Texture *texture, int level, int width, int height, int depth, int pitchP, int sliceP);
 
-	void initialize(VkDescriptorSet descriptorSet);
+	void initialize(DescriptorSet* descriptorSet);
 
 	// Returns the total size of the descriptor set in bytes.
 	size_t getDescriptorSetAllocationSize() const;

src/Vulkan/VkGetProcAddress.cpp

@@ -323,7 +323,7 @@ static const std::vector<std::pair<const char*, std::unordered_map<std::string,
 
 #undef MAKE_VULKAN_DEVICE_ENTRY
 
-PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const char* pName)
+PFN_vkVoidFunction GetInstanceProcAddr(Instance* instance, const char* pName)
 {
 	auto globalFunction = globalFunctionPointers.find(std::string(pName));
 	if(globalFunction != globalFunctionPointers.end())
@@ -331,7 +331,7 @@ PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const char* pName)
 		return globalFunction->second;
 	}
 
-	if(instance != VK_NULL_HANDLE)
+	if(instance != nullptr)
 	{
 		auto instanceFunction = instanceFunctionPointers.find(std::string(pName));
 		if(instanceFunction != instanceFunctionPointers.end())
@@ -358,7 +358,7 @@ PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const char* pName)
 	return nullptr;
 }
 
-PFN_vkVoidFunction GetDeviceProcAddr(VkDevice device, const char* pName)
+PFN_vkVoidFunction GetDeviceProcAddr(Device* device, const char* pName)
 {
 	auto deviceFunction = deviceFunctionPointers.find(std::string(pName));
 	if(deviceFunction != deviceFunctionPointers.end())
@@ -366,10 +366,9 @@ PFN_vkVoidFunction GetDeviceProcAddr(VkDevice device, const char* pName)
 		return deviceFunction->second;
 	}
 
-	vk::Device* myDevice = Cast(device);
 	for(const auto& deviceExtensionFunctions : deviceExtensionFunctionPointers)
 	{
-		if(myDevice->hasExtension(deviceExtensionFunctions.first))
+		if(device->hasExtension(deviceExtensionFunctions.first))
 		{
 			deviceFunction = deviceExtensionFunctions.second.find(std::string(pName));
 			if(deviceFunction != deviceExtensionFunctions.second.end())

src/Vulkan/VkGetProcAddress.h

@@ -19,8 +19,13 @@
 
 namespace vk
 {
-PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const char* pName);
-PFN_vkVoidFunction GetDeviceProcAddr(VkDevice device, const char* pName);
+
+class Device;
+class Instance;
+
+PFN_vkVoidFunction GetInstanceProcAddr(Instance* instance, const char* pName);
+PFN_vkVoidFunction GetDeviceProcAddr(Device* device, const char* pName);
+
 }
 
 #endif // VK_UTILS_HPP_
\ No newline at end of file

src/Vulkan/VkImage.cpp

@@ -96,9 +96,9 @@ const VkMemoryRequirements Image::getMemoryRequirements() const
 	return memoryRequirements;
 }
 
-void Image::bind(VkDeviceMemory pDeviceMemory, VkDeviceSize pMemoryOffset)
+void Image::bind(DeviceMemory* pDeviceMemory, VkDeviceSize pMemoryOffset)
 {
-	deviceMemory = Cast(pDeviceMemory);
+	deviceMemory = pDeviceMemory;
 	memoryOffset = pMemoryOffset;
 	if(decompressedImage)
 	{

src/Vulkan/VkImage.hpp

@@ -35,7 +35,7 @@ public:
 
 	const VkMemoryRequirements getMemoryRequirements() const;
 	void getSubresourceLayout(const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) const;
-	void bind(VkDeviceMemory pDeviceMemory, VkDeviceSize pMemoryOffset);
+	void bind(DeviceMemory* pDeviceMemory, VkDeviceSize pMemoryOffset);
 	void copyTo(Image* dstImage, const VkImageCopy& pRegion) const;
 	void copyTo(Buffer* dstBuffer, const VkBufferImageCopy& region);
 	void copyFrom(Buffer* srcBuffer, const VkBufferImageCopy& region);

src/Vulkan/VkQueue.cpp

@@ -91,14 +91,14 @@ Queue::~Queue()
 	garbageCollect();
 }
 
-VkResult Queue::submit(uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence)
+VkResult Queue::submit(uint32_t submitCount, const VkSubmitInfo* pSubmits, Fence* fence)
 {
 	garbageCollect();
 
 	Task task;
 	task.submitCount = submitCount;
 	task.pSubmits = DeepCopySubmitInfo(submitCount, pSubmits);
-	task.events = (fence != VK_NULL_HANDLE) ? vk::Cast(fence) : nullptr;
+	task.events = fence;
 
 	if(task.events)
 	{

src/Vulkan/VkQueue.hpp

@@ -31,6 +31,8 @@ namespace sw
 namespace vk
 {
 
+class Fence;
+
 class Queue
 {
 	VK_LOADER_DATA loaderData = { ICD_LOADER_MAGIC };
@@ -44,7 +46,7 @@ public:
 		return reinterpret_cast<VkQueue>(this);
 	}
 
-	VkResult submit(uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence);
+	VkResult submit(uint32_t submitCount, const VkSubmitInfo* pSubmits, Fence* fence);
 	VkResult waitIdle();
 #ifndef __ANDROID__
 	void present(const VkPresentInfoKHR* presentInfo);

src/WSI/VkSurfaceKHR.cpp

@@ -169,9 +169,9 @@ VkResult SurfaceKHR::getPresentModes(uint32_t *pPresentModeCount, VkPresentModeK
 	return VK_SUCCESS;
 }
 
-void SurfaceKHR::associateSwapchain(VkSwapchainKHR swapchain)
+void SurfaceKHR::associateSwapchain(SwapchainKHR* swapchain)
 {
-	associatedSwapchain = Cast(swapchain);
+	associatedSwapchain = swapchain;
 }
 
 void SurfaceKHR::disassociateSwapchain()

src/WSI/VkSurfaceKHR.hpp

@@ -83,7 +83,7 @@ public:
 	virtual void detachImage(PresentImage* image) = 0;
 	virtual void present(PresentImage* image) = 0;
 
-	void associateSwapchain(VkSwapchainKHR swapchain);
+	void associateSwapchain(SwapchainKHR* swapchain);
 	void disassociateSwapchain();
 	bool hasAssociatedSwapchain();
 

src/WSI/VkSwapchainKHR.cpp

@@ -171,7 +171,7 @@ VkResult SwapchainKHR::getImages(uint32_t *pSwapchainImageCount, VkImage *pSwapc
 	return VK_SUCCESS;
 }
 
-VkResult SwapchainKHR::getNextImage(uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t *pImageIndex)
+VkResult SwapchainKHR::getNextImage(uint64_t timeout, Semaphore* semaphore, Fence* fence, uint32_t *pImageIndex)
 {
 	for(uint32_t i = 0; i < imageCount; i++)
 	{
@@ -183,12 +183,12 @@ VkResult SwapchainKHR::getNextImage(uint64_t timeout, VkSemaphore semaphore, VkF
 
 			if(semaphore)
 			{
-				vk::Cast(semaphore)->signal();
+				semaphore->signal();
 			}
 
 			if(fence)
 			{
-				vk::Cast(fence)->complete();
+				fence->complete();
 			}
 
 			return VK_SUCCESS;

src/WSI/VkSwapchainKHR.hpp

@@ -25,6 +25,9 @@
 namespace vk
 {
 
+class Fence;
+class Semaphore;
+
 class SwapchainKHR : public Object<SwapchainKHR, VkSwapchainKHR>
 {
 public:
@@ -41,7 +44,7 @@ public:
 	uint32_t getImageCount() const;
 	VkResult getImages(uint32_t *pSwapchainImageCount, VkImage *pSwapchainImages) const;
 
-	VkResult getNextImage(uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex);
+	VkResult getNextImage(uint64_t timeout, Semaphore* semaphore, Fence* fence, uint32_t* pImageIndex);
 
 	void present(uint32_t index);