vkAcquireNextImageKHR and vkQueuePresentKHR

src/Vulkan/VkGetProcAddress.cpp

@@ -251,6 +251,8 @@ static const std::unordered_map<std::string, PFN_vkVoidFunction> deviceFunctionP
 	MAKE_VULKAN_DEVICE_ENTRY(vkCreateSwapchainKHR),
 	MAKE_VULKAN_DEVICE_ENTRY(vkDestroySwapchainKHR),
 	MAKE_VULKAN_DEVICE_ENTRY(vkGetSwapchainImagesKHR),
+	MAKE_VULKAN_DEVICE_ENTRY(vkAcquireNextImageKHR),
+	MAKE_VULKAN_DEVICE_ENTRY(vkQueuePresentKHR),
 };
 #undef MAKE_VULKAN_DEVICE_ENTRY
 

src/Vulkan/VkQueue.cpp

@@ -17,6 +17,7 @@
 #include "VkQueue.hpp"
 #include "VkSemaphore.hpp"
 #include "Device/Renderer.hpp"
+#include "WSI/VkSwapchainKHR.hpp"
 
 namespace vk
 {
@@ -65,12 +66,20 @@ void Queue::submit(uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence f
 	}
 }
 
-void Queue::waitIdle()
-{
-	// equivalent to submitting a fence to a queue and waiting
-	// with an infinite timeout for that fence to signal
-
-	// FIXME (b/117835459): implement once we have working fences
+void Queue::waitIdle()
+{
+	// equivalent to submitting a fence to a queue and waiting
+	// with an infinite timeout for that fence to signal
+
+	// FIXME (b/117835459): implement once we have working fences
+}
+
+void Queue::present(const VkPresentInfoKHR* presentInfo)
+{
+	for(uint32_t i = 0; i < presentInfo->swapchainCount; i++)
+	{
+		vk::Cast(presentInfo->pSwapchains[i])->present(presentInfo->pImageIndices[i]);
+	}
 }
 
 } // namespace vk
\ No newline at end of file

src/Vulkan/VkQueue.hpp

@@ -43,6 +43,7 @@ public:
 	void destroy();
 	void submit(uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence);
 	void waitIdle();
+	void present(const VkPresentInfoKHR* presentInfo);
 
 private:
 	sw::Context* context = nullptr;

src/Vulkan/libVulkan.cpp

@@ -2212,4 +2212,22 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR(VkDevice device, VkSwapch
 	return vk::Cast(swapchain)->getImages(pSwapchainImageCount, pSwapchainImages);
 }
 
+VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex)
+{
+	TRACE("(VkDevice device = 0x%X, VkSwapchainKHR swapchain = 0x%X, uint64_t timeout = 0x%X, VkSemaphore semaphore = 0x%X, VkFence fence = 0x%X, uint32_t* pImageIndex = 0x%X)",
+			device, swapchain, timeout, semaphore, fence, pImageIndex);
+
+	return vk::Cast(swapchain)->getNextImage(timeout, semaphore, fence, pImageIndex);
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* pPresentInfo)
+{
+	TRACE("(VkQueue queue = 0x%X, const VkPresentInfoKHR* pPresentInfo = 0x%X)",
+			queue, pPresentInfo);
+
+	vk::Cast(queue)->present(pPresentInfo);
+
+	return VK_SUCCESS;
+}
+
 }

src/WSI/VkSurfaceKHR.cpp

@@ -83,6 +83,4 @@ VkResult SurfaceKHR::getPresentModes(uint32_t *pPresentModeCount, VkPresentModeK
 	return VK_SUCCESS;
 }
 
-
-
 }
\ No newline at end of file

src/WSI/VkSurfaceKHR.hpp

@@ -45,6 +45,8 @@ public:
 	uint32_t getPresentModeCount() const;
 	VkResult getPresentModes(uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) const;
 
+	virtual void present(VkImage image, VkDeviceMemory imageData) = 0;
+
 private:
 	const std::vector<VkSurfaceFormatKHR> surfaceFormats =
 	{

src/WSI/VkSwapchainKHR.cpp

@@ -146,4 +146,39 @@ VkResult SwapchainKHR::getImages(uint32_t *pSwapchainImageCount, VkImage *pSwapc
 	return VK_SUCCESS;
 }
 
+VkResult SwapchainKHR::getNextImage(uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t *pImageIndex)
+{
+	for(uint32_t i = 0; i < getImageCount(); i++)
+	{
+		PresentImage& currentImage = images[i];
+		if(currentImage.imageStatus == AVAILABLE)
+		{
+			currentImage.imageStatus = DRAWING;
+			*pImageIndex = i;
+
+			if(semaphore)
+			{
+				vk::Cast(semaphore)->signal();
+			}
+
+			if(fence)
+			{
+				vk::Cast(fence)->signal();
+			}
+
+			return VK_SUCCESS;
+		}
+	}
+
+	return VK_NOT_READY;
+}
+
+void SwapchainKHR::present(uint32_t index)
+{
+	auto & image = images[index];
+	image.imageStatus = PRESENTING;
+	vk::Cast(createInfo.surface)->present(image.image, image.imageMemory);
+	image.imageStatus = AVAILABLE;
+}
+
 }
\ No newline at end of file

src/WSI/VkSwapchainKHR.hpp

@@ -54,6 +54,10 @@ 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);
+
+	void present(uint32_t index);
+
 private:
 	VkSwapchainCreateInfoKHR createInfo;
 	std::vector<PresentImage> images;

src/WSI/XlibSurfaceKHR.cpp

@@ -11,23 +11,49 @@
 
 #include "XlibSurfaceKHR.hpp"
 
+#include "Vulkan/VkDeviceMemory.hpp"
+
+#include <string.h>
+
 namespace vk {
 
 XlibSurfaceKHR::XlibSurfaceKHR(const VkXlibSurfaceCreateInfoKHR *pCreateInfo, void *mem) :
 		pDisplay(pCreateInfo->dpy),
-		window(pCreateInfo->window) {
+		window(pCreateInfo->window)
+{
+	int screen = DefaultScreen(pDisplay);
+	gc = libX11->XDefaultGC(pDisplay, screen);
 
-}
+	XVisualInfo xVisual;
+	Status status = libX11->XMatchVisualInfo(pDisplay, screen, 32, TrueColor, &xVisual);
+	bool match = (status != 0 && xVisual.blue_mask ==0xFF);
+	Visual *visual = match ? xVisual.visual : libX11->XDefaultVisual(pDisplay, screen);
+
+	XWindowAttributes attr;
+	libX11->XGetWindowAttributes(pDisplay, window, &attr);
+
+	int bytes_per_line = attr.width * 4;
+	int bytes_per_image = attr.height * bytes_per_line;
+
+	xImage = libX11->XCreateImage(pDisplay, visual, attr.depth, ZPixmap, 0, nullptr, attr.width, attr.height, 32, bytes_per_line);
 
-void XlibSurfaceKHR::destroySurface(const VkAllocationCallbacks *pAllocator) {
+}
 
+void XlibSurfaceKHR::destroySurface(const VkAllocationCallbacks *pAllocator)
+{
+	if(xImage)
+	{
+		XDestroyImage(xImage);
+	}
 }
 
-size_t XlibSurfaceKHR::ComputeRequiredAllocationSize(const VkXlibSurfaceCreateInfoKHR *pCreateInfo) {
+size_t XlibSurfaceKHR::ComputeRequiredAllocationSize(const VkXlibSurfaceCreateInfoKHR *pCreateInfo)
+{
 	return 0;
 }
 
-void XlibSurfaceKHR::getSurfaceCapabilities(VkSurfaceCapabilitiesKHR *pSurfaceCapabilities) const {
+void XlibSurfaceKHR::getSurfaceCapabilities(VkSurfaceCapabilitiesKHR *pSurfaceCapabilities) const
+{
 	SurfaceKHR::getSurfaceCapabilities(pSurfaceCapabilities);
 
 	XWindowAttributes attr;
@@ -39,4 +65,16 @@ void XlibSurfaceKHR::getSurfaceCapabilities(VkSurfaceCapabilitiesKHR *pSurfaceCa
 	pSurfaceCapabilities->maxImageExtent = extent;
 }
 
+void XlibSurfaceKHR::present(VkImage image, VkDeviceMemory imageData)
+{
+	xImage->data = static_cast<char*>(vk::Cast(imageData)->getOffsetPointer(0));
+
+	XWindowAttributes attr;
+	libX11->XGetWindowAttributes(pDisplay, window, &attr);
+
+	libX11->XPutImage(pDisplay, window, gc, xImage, 0, 0, 0, 0, attr.width, attr.height);
+
+	xImage->data = nullptr;
+}
+
 }
\ No newline at end of file

src/WSI/XlibSurfaceKHR.hpp

@@ -33,10 +33,13 @@ public:
 
 	void getSurfaceCapabilities(VkSurfaceCapabilitiesKHR *pSurfaceCapabilities) const override;
 
+	void present(VkImage image, VkDeviceMemory imageData) override;
+
 private:
 	Display *pDisplay;
 	Window window;
-
+	GC gc;
+	XImage *xImage = nullptr;
 };
 
 }