Merge pull request #6 from msiglreith/xcb

Surface and Swapchain extensions

.gitignore

@@ -1,3 +1,4 @@
+/build/
 /target/
 **/*.rs.bk
 Cargo.lock

CMakeLists.txt

@@ -0,0 +1,14 @@
+cmake_minimum_required (VERSION 2.6)
+project (portability)
+
+include_directories("modules/vulkan-docs/src")
+add_executable(native_test native/test.cpp native/window.cpp)
+
+find_library(PORTABILITY_LIB portability "target/debug")
+target_link_libraries(native_test ${PORTABILITY_LIB})
+
+if (WIN32)
+    target_link_libraries(native_test Dwmapi Userenv ws2_32)
+else (WIN32)
+    target_link_libraries(native_test pthread dl m X11 xcb)
+endif (WIN32)

Makefile

@@ -2,13 +2,13 @@ VULKAN_DIR=modules/vulkan-docs/src
 BINDING=target/vulkan.rs
 NATIVE_DIR=target/native
 TARGET=$(NATIVE_DIR)/test
-OBJECTS=$(NATIVE_DIR)/test.o
+OBJECTS=$(NATIVE_DIR)/test.o $(NATIVE_DIR)/window.o
 LIBRARY=target/debug/libportability.a
 
 CC=g++
-CFLAGS=-ggdb -O0 -I$(VULKAN_DIR)
+CFLAGS=-std=c++11 -ggdb -O0 -I$(VULKAN_DIR)
 DEPS=
-LDFLAGS=-lpthread -ldl -lm -lX11
+LDFLAGS=-lpthread -ldl -lm -lX11 -lxcb
 
 .PHONY: all binding run
 

README.md

@@ -2,3 +2,26 @@
 [![Build Status](https://travis-ci.org/kvark/portability.svg?branch=master)](https://travis-ci.org/kvark/portability)
 
 This is a prototype static library implementing [Vulkan Portability Initiative](https://www.khronos.org/blog/khronos-announces-the-vulkan-portability-initiative) using gfx-rs [low-level core](http://gfx-rs.github.io/2017/07/24/low-level.html). See gfx-rs [meta issue](https://github.com/gfx-rs/gfx/issues/1354) for backend limitations and further details.
+
+## Build
+
+### Makefile (Unix)
+```
+make
+```
+
+### CMake (Window)
+Build the Rust library (portability implementation):
+
+```
+cargo build
+```
+
+Build the native example:
+
+```
+mkdir build
+cd build
+cmake ..
+cmake --build . --target native_test
+```

native/test.cpp

@@ -1,10 +1,13 @@
 /// Sample code adopted from https://github.com/LunarG/VulkanSamples
 
+#if defined(_WIN32)
+#define VK_USE_PLATFORM_WIN32_KHR
+#endif
+
 #include <vulkan/vulkan.h>
 #include <assert.h>
 #include <stdio.h>
-
+#include "window.hpp"
-extern "C" VkSurfaceKHR vkCreateSurfaceGFX(VkInstance);
 
 int main() {
     printf("starting the portability test\n");
@@ -24,8 +27,20 @@ int main() {
         return -1;
     }
 
-    VkSurfaceKHR surface = vkCreateSurfaceGFX(instance);
+    // Window initialization
-    printf("\tvkCreateSurfaceGFX\n");
+    Config config = { 10, 10, 800, 600 };
+    Window window = new_window(config);
+
+    VkSurfaceKHR surface;
+
+#if defined(_WIN32)
+    VkWin32SurfaceCreateInfoKHR surface_info = {};
+    surface_info.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
+    surface_info.hinstance = window.instance;
+    surface_info.hwnd = window.window;
+    vkCreateWin32SurfaceKHR(instance, &surface_info, NULL, &surface);
+#endif
+    printf("\tvkCreateSurfaceKHR\n");
 
     uint32_t adapter_count = 1;
     VkPhysicalDevice physical_devices[1] = {};
@@ -52,6 +67,22 @@ int main() {
     printf("\tusing queue family index %d\n", queue_family_index);
     assert(queue_family_index >= 0);
 
+    VkDeviceQueueCreateInfo queue_info = {};
+    float queue_priorities[1] = {0.0};
+    queue_info.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
+    queue_info.queueCount = 1;
+    queue_info.pQueuePriorities = queue_priorities;
+
+    VkDeviceCreateInfo device_info = {};
+    device_info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
+    device_info.queueCreateInfoCount = 1;
+    device_info.pQueueCreateInfos = &queue_info;
+
+    VkDevice device = 0;
+    res = vkCreateDevice(physical_devices[0], &device_info, NULL, &device);
+    printf("\tvkCreateDevice: res=%d\n", res);
+    assert(!res);
+
     VkSurfaceFormatKHR surfFormats[20];
     uint32_t formatCount = sizeof(surfFormats) / sizeof(surfFormats[0]);
     res = vkGetPhysicalDeviceSurfaceFormatsKHR(physical_devices[0], surface, &formatCount, surfFormats);
@@ -87,11 +118,11 @@ int main() {
 
     VkCompositeAlphaFlagBitsKHR compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
 
-    /*VkSwapchainCreateInfoKHR swapchain_ci = {0};
+    VkSwapchainCreateInfoKHR swapchain_ci = {};
     swapchain_ci.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
-    swapchain_ci.surface = info.surface;
+    swapchain_ci.surface = surface;
     swapchain_ci.minImageCount = desiredNumberOfSwapChainImages;
-    swapchain_ci.imageFormat = info.format;
+    swapchain_ci.imageFormat = surfFormats[0].format;
     swapchain_ci.imageExtent.width = swapchainExtent.width;
     swapchain_ci.imageExtent.height = swapchainExtent.height;
     swapchain_ci.preTransform = preTransform;
@@ -102,22 +133,23 @@ int main() {
     swapchain_ci.clipped = true;
     swapchain_ci.imageColorSpace = VK_COLORSPACE_SRGB_NONLINEAR_KHR;
     swapchain_ci.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
-    swapchain_ci.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;*/
+    swapchain_ci.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
 
-    VkDeviceQueueCreateInfo queue_info = {};
+    VkSwapchainKHR swapchain = 0;
-    float queue_priorities[1] = {0.0};
+    res = vkCreateSwapchainKHR(device, &swapchain_ci, NULL, &swapchain);
-    queue_info.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
+    printf("\tvkCreateSwapchainKHR: res=%d\n", res);
-    queue_info.queueCount = 1;
-    queue_info.pQueuePriorities = queue_priorities;
 
-    VkDeviceCreateInfo device_info = {};
-    device_info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
-    device_info.queueCreateInfoCount = 1;
-    device_info.pQueueCreateInfos = &queue_info;
 
-    VkDevice device = 0;
+    uint32_t image_count = 0;
-    res = vkCreateDevice(physical_devices[0], &device_info, NULL, &device);
+    res = vkGetSwapchainImagesKHR(device, swapchain, &image_count, NULL);
-    printf("\tvkCreateDevice: res=%d\n", res);
+    printf("\tvkCreateSwapchainKHR (query): res=%d image_count=%d\n", res, image_count);
+    assert(!res);
+
+    VkImage *swapchain_images = new VkImage[image_count];
+    assert(swapchain_images);
+
+    res = vkGetSwapchainImagesKHR(device, swapchain, &image_count, swapchain_images);
+    printf("\tvkCreateSwapchainKHR: res=%d\n", res);
     assert(!res);
 
     VkCommandPool cmd_pool = 0;
@@ -144,11 +176,21 @@ int main() {
     assert(!res);
 
     // Some work...
+    while(poll_events()) {
 
+    }
+
+    delete[] swapchain_images;
+    vkDestroySwapchainKHR(device, swapchain, NULL);
+    printf("\tvkDestroySwapchainKHR\n");
     vkFreeCommandBuffers(device, cmd_pool, 1, &cmd_buffer);
+    printf("\tvkFreeCommandBuffers\n");
     vkDestroyCommandPool(device, cmd_pool, NULL);
+    printf("\tvkDestroyCommandPool\n");
     vkDestroySurfaceKHR(instance, surface, NULL);
+    printf("\tvkDestroySurfaceKHR\n");
     vkDestroyDevice(device, NULL);
+    printf("\tvkDestroyDevice\n");
     vkDestroyInstance(instance, NULL);
 
     printf("done.\n");

native/window.cpp

@@ -0,0 +1,116 @@
+
+#include <stdio.h>
+
+#include "window.hpp"
+
+#if defined(_WIN32)
+const char *CLASS_NAME = "PortabilityClass";
+
+auto WINAPI window_func(HWND hwnd, UINT u_msg, WPARAM w_param, LPARAM l_param) -> LRESULT {
+    if (u_msg == WM_CLOSE) {
+        PostQuitMessage(0);
+    }
+    return DefWindowProc(hwnd, u_msg, w_param, l_param);
+}
+
+auto register_class(HINSTANCE hinstance) -> bool {
+    WNDCLASS wclass = {0};
+
+    wclass.style = CS_HREDRAW | CS_VREDRAW;
+    wclass.lpszClassName = CLASS_NAME;
+    wclass.hInstance = hinstance;
+    wclass.lpfnWndProc = window_func;
+    wclass.hCursor = LoadCursor(NULL, IDC_ARROW);
+
+     if(!RegisterClass(&wclass)) {
+        printf("Couldn't register window class");
+        return false;
+     }
+
+     return true;
+}
+
+auto new_window(Config config) -> Window {
+    auto hinstance = GetModuleHandle(0);
+    register_class(hinstance);
+
+    RECT rect;
+
+    rect.left = config.x; rect.right = config.x + config.width;
+    rect.top = config.y;  rect.bottom = config.y + config.height;
+
+    AdjustWindowRectEx(&rect, 0, false, 0);
+
+    auto hwnd = ::CreateWindow(
+        CLASS_NAME,
+        "GfxPortability",
+        WS_THICKFRAME | WS_SYSMENU,
+        rect.left,
+        rect.top,
+        rect.right-rect.left,
+        rect.bottom-rect.top,
+        NULL,
+        NULL,
+        ::GetModuleHandle(0),
+        NULL
+    );
+
+    if(!hwnd) {
+        printf("Couldn't create window! error: %d", ::GetLastError());
+    }
+
+    ::ShowWindow(hwnd, SW_SHOWDEFAULT);
+    ::UpdateWindow(hwnd);
+
+    Window window = { hinstance, hwnd };
+    return window;
+}
+
+auto poll_events() -> bool {
+    MSG msg;
+    while(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
+        if (msg.message == WM_QUIT) {
+            return false;
+        }
+        TranslateMessage(&msg);
+        DispatchMessage(&msg);
+    }
+    return true;
+}
+
+#else
+auto new_window(Config config) -> Window {
+    auto connection = xcb_connect(NULL, NULL);
+
+    auto setup = xcb_get_setup(connection);
+    auto screen_iterator = xcb_setup_roots_iterator(setup);
+    auto screen = screen_iterator.data;
+
+    auto hwnd = xcb_generate_id(connection);
+    xcb_create_window(
+        connection,
+        XCB_COPY_FROM_PARENT,
+        hwnd,
+        screen->root,
+        config.x,
+        config.y,
+        config.width,
+        config.height,
+        0,
+        XCB_WINDOW_CLASS_INPUT_OUTPUT,
+        screen->root_visual,
+        0,
+        NULL);
+
+    xcb_map_window(connection, hwnd);
+    xcb_flush(connection);
+
+    Window window = Window { connection, hwnd };
+    return window;
+}
+
+auto poll_events() -> bool {
+    return true;
+}
+
+#endif

native/window.hpp

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <stdint.h>
+
+#if defined(_WIN32)
+#include <windows.h>
+#else
+#include <xcb/xcb.h>
+#endif
+
+struct Window {
+#if defined(_WIN32)
+    HINSTANCE instance;
+    HWND window;
+#else
+    xcb_connection_t *connection;
+    xcb_drawable_t window;
+#endif
+};
+
+struct Config {
+    uint32_t x;
+    uint32_t y;
+    uint32_t width;
+    uint32_t height;
+};
+
+auto new_window(Config config) -> Window;
+auto poll_events() -> bool;

src/conv.rs

@@ -41,6 +41,21 @@ pub fn format_from_hal(format: format::Format) -> VkFormat {
     }
 }
 
+pub fn hal_from_format(format: VkFormat) -> format::Format {
+    use VkFormat::*;
+    use hal::format::ChannelType::*;
+    use hal::format::SurfaceType::*;
+
+    let (sf, cf) = match format {
+        VK_FORMAT_B8G8R8A8_UNORM => (B8_G8_R8_A8, Unorm),
+        _ => {
+            panic!("format {:?}", format);
+        }
+    };
+
+    format::Format(sf, cf)
+}
+
 pub fn extent2d_from_hal(extent: window::Extent2d) -> VkExtent2D {
     VkExtent2D {
         width: extent.width,

src/lib.rs

@@ -498,12 +498,9 @@ pub struct VkBuffer_T {
     _unused: [u8; 0],
 }
 pub type VkBuffer = *mut VkBuffer_T;
-#[repr(C)]
+
-#[derive(Debug, Copy, Clone)]
+pub type VkImage = Handle<<B as hal::Backend>::Image>;
-pub struct VkImage_T {
+
-    _unused: [u8; 0],
-}
-pub type VkImage = *mut VkImage_T;
 #[repr(C)]
 #[derive(Debug, Copy, Clone)]
 pub struct VkEvent_T {
@@ -5206,16 +5203,7 @@ extern "C" {
 
 //NOTE: all *KHR types have to be pure `Handle` things for compatibility with
 //`VK_DEFINE_NON_DISPATCHABLE_HANDLE` used in `vulkan.h`
-#[repr(C)]
+pub type VkSurfaceKHR = Handle<<B as hal::Backend>::Surface>;
-pub struct VkSurfaceInner<Backend: hal::Backend> {
-    raw: Backend::Surface,
-    window: winit::Window,
-    events_loop: winit::EventsLoop,
-}
-pub type VkSurfaceKHR = Handle<VkSurfaceInner<B>>;
-
-// TODO: temporary surface type, should be replacing `VkSurfaceKHR` in the future.
-pub type VkSurfaceRawKHR = Handle<<B as hal::Backend>::Surface>;
 
 pub const VkColorSpaceKHR_VK_COLOR_SPACE_BEGIN_RANGE_KHR: VkColorSpaceKHR =
     VkColorSpaceKHR::VK_COLOR_SPACE_SRGB_NONLINEAR_KHR;
@@ -5346,7 +5334,7 @@ pub extern fn vkGetPhysicalDeviceSurfaceSupportKHR(
     pSupported: *mut VkBool32,
 ) -> VkResult {
     let family = &adapter.queue_families[queueFamilyIndex as usize];
-    let supports = surface.raw.supports_queue_family(family);
+    let supports = surface.supports_queue_family(family);
     unsafe { *pSupported = supports as _ };
     VkResult::VK_SUCCESS
 }
@@ -5357,7 +5345,7 @@ pub extern fn vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
     surface: VkSurfaceKHR,
     pSurfaceCapabilities: *mut VkSurfaceCapabilitiesKHR,
 ) -> VkResult {
-    let (caps, _) = surface.raw.capabilities_and_formats(&adapter.physical_device);
+    let (caps, _) = surface.capabilities_and_formats(&adapter.physical_device);
 
     let output = VkSurfaceCapabilitiesKHR {
         minImageCount: caps.image_count.start,
@@ -5389,7 +5377,7 @@ pub extern fn vkGetPhysicalDeviceSurfaceFormatsKHR(
     pSurfaceFormatCount: *mut u32,
     pSurfaceFormats: *mut VkSurfaceFormatKHR,
 ) -> VkResult {
-    let (_, formats) = surface.raw.capabilities_and_formats(&adapter.physical_device);
+    let (_, formats) = surface.capabilities_and_formats(&adapter.physical_device);
     let output = unsafe { slice::from_raw_parts_mut(pSurfaceFormats, *pSurfaceFormatCount as usize) };
 
     if output.len() > formats.len() {
@@ -5425,27 +5413,11 @@ pub extern fn vkGetPhysicalDeviceSurfacePresentModesKHR(
     VkResult::VK_SUCCESS
 }
 
-/// This is an EXTRA function not in original vulkan.h
+pub struct Swapchain {
-#[no_mangle]
+    raw: <B as hal::Backend>::Swapchain,
-pub extern fn vkCreateSurfaceGFX(instance: VkInstance) -> VkSurfaceKHR {
+    images: Vec<VkImage>,
-    let events_loop = winit::EventsLoop::new();
-    let window = winit::Window::new(&events_loop).unwrap();
-
-    let inner = VkSurfaceInner {
-        raw: instance.create_surface(&window),
-        window: window,
-        events_loop: events_loop,
-    };
-
-    Handle::new(inner)
 }
-
+pub type VkSwapchainKHR = Handle<Swapchain>;
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct VkSwapchainKHR_T {
-    _unused: [u8; 0],
-}
-pub type VkSwapchainKHR = *mut VkSwapchainKHR_T;
 #[repr(u32)]
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub enum VkSwapchainCreateFlagBitsKHR {
@@ -5526,22 +5498,87 @@ pub type PFN_vkQueuePresentKHR =
                                                pPresentInfo:
                                                    *const VkPresentInfoKHR)
                               -> VkResult>;
-extern "C" {
+#[no_mangle]
-    pub fn vkCreateSwapchainKHR(device: VkDevice,
+pub extern fn vkCreateSwapchainKHR(
-                                pCreateInfo: *const VkSwapchainCreateInfoKHR,
+    gpu: VkDevice,
-                                pAllocator: *const VkAllocationCallbacks,
+    pCreateInfo: *const VkSwapchainCreateInfoKHR,
-                                pSwapchain: *mut VkSwapchainKHR) -> VkResult;
+    _pAllocator: *const VkAllocationCallbacks,
+    pSwapchain: *mut VkSwapchainKHR,
+) -> VkResult {
+    let info = unsafe { &*pCreateInfo };
+    // TODO: more checks
+    assert_eq!(info.clipped, VK_TRUE); // TODO
+    assert_eq!(info.imageSharingMode, VkSharingMode::VK_SHARING_MODE_EXCLUSIVE); // TODO
+
+    let config = hal::SwapchainConfig {
+        color_format: conv::hal_from_format(info.imageFormat),
+        depth_stencil_format: None,
+        image_count: info.minImageCount,
+    };
+    let (swapchain, backbuffers) = gpu.device.create_swapchain(&mut info.surface.clone(), config);
+
+    let images = match backbuffers {
+        hal::Backbuffer::Images(images) => {
+            images.into_iter().map(|image| Handle::new(image)).collect()
+        },
+        hal::Backbuffer::Framebuffer(_) => {
+            panic!("Expected backbuffer images. Backends returning only framebuffers are not supported!")
+        },
+    };
+
+    let swapchain = Swapchain {
+        raw: swapchain,
+        images,
+    };
+
+    unsafe { *pSwapchain = Handle::new(swapchain) };
+    VkResult::VK_SUCCESS
 }
-extern "C" {
+#[no_mangle]
-    pub fn vkDestroySwapchainKHR(device: VkDevice, swapchain: VkSwapchainKHR,
+pub extern fn vkDestroySwapchainKHR(
-                                 pAllocator: *const VkAllocationCallbacks);
+    device: VkDevice,
+    mut swapchain: VkSwapchainKHR,
+    pAllocator: *const VkAllocationCallbacks,
+) {
+    for image in &mut swapchain.images {
+        let _ = image.unwrap();
+    }
+    let _ = swapchain.unwrap();
 }
-extern "C" {
+#[no_mangle]
-    pub fn vkGetSwapchainImagesKHR(device: VkDevice,
+pub extern fn vkGetSwapchainImagesKHR(
-                                   swapchain: VkSwapchainKHR,
+    device: VkDevice,
-                                   pSwapchainImageCount: *mut u32,
+    swapchain: VkSwapchainKHR,
-                                   pSwapchainImages: *mut VkImage)
+    pSwapchainImageCount: *mut u32,
-     -> VkResult;
+    pSwapchainImages: *mut VkImage,
+) -> VkResult {
+    debug_assert!(!pSwapchainImageCount.is_null());
+
+    let swapchain_image_count = unsafe { *pSwapchainImageCount };
+    let available_images = swapchain.images.len();
+
+    if pSwapchainImages.is_null() {
+        // If NULL the number of presentable images is returned.
+        unsafe { *pSwapchainImageCount = swapchain.images.len() as _; }
+    } else {
+        let num_images = available_images.min(swapchain_image_count as _);
+        let swapchain_images = unsafe {
+            slice::from_raw_parts_mut(pSwapchainImages, num_images)
+        };
+
+        for i in 0..num_images as _ {
+            swapchain_images[i] = swapchain.images[i];
+        }
+
+        // Overwrite pSwapchainImageCount with actual image count
+        unsafe { *pSwapchainImageCount = num_images as _; }
+
+        if num_images < available_images {
+            return VkResult::VK_INCOMPLETE;
+        }
+    }
+
+    VkResult::VK_SUCCESS
 }
 extern "C" {
     pub fn vkAcquireNextImageKHR(device: VkDevice, swapchain: VkSwapchainKHR,
@@ -5821,11 +5858,11 @@ impl Clone for VkWin32SurfaceCreateInfoKHR {
     fn clone(&self) -> Self { *self }
 }
 #[no_mangle]
-pub fn vkCreateWin32SurfaceKHR(
+pub extern fn vkCreateWin32SurfaceKHR(
     instance: VkInstance,
     pCreateInfos: *const VkWin32SurfaceCreateInfoKHR,
     pAllocator: *const VkAllocationCallbacks,
-    pSurface: *mut VkSurfaceRawKHR,
+    pSurface: *mut VkSurfaceKHR,
 ) -> VkResult {
     #[cfg(target_os = "windows")]
     {
@@ -5833,7 +5870,12 @@ pub fn vkCreateWin32SurfaceKHR(
             assert_eq!((*pCreateInfos).flags, 0);
             assert!(pAllocator.is_null());
             // TODO: handle HINSTANCE
-            *pSurface = Handle::new(instance.create_surface_from_hwnd((*pCreateInfos).hwnd));
+            *pSurface = Handle::new(
+                instance.create_surface_from_hwnd(
+                    (*pCreateInfos).hinstance,
+                    (*pCreateInfos).hwnd,
+                )
+            );
             VkResult::VK_SUCCESS
         }
     }