main.cxx

#include <stdio.h>
#include <string.h>
#include <vector>
#include <string>
#include <malloc.h>
#include <iostream>
#include <sstream>
#include <assert.h>
#include <algorithm>
#include <fstream>

#ifdef WIN32
#include <Windows.h>
#elif defined(__linux__)
#include <xcb/xcb.h>
#endif

#include "vulkanhelper.hxx"

#include "raytracing.hxx"


#define WIDTH 1280
#define HEIGHT 720
#define VSYNC

uint32_t getMemoryType(VkPhysicalDeviceMemoryProperties& gpuMemProps, VkMemoryRequirements& memoryRequirements, VkMemoryPropertyFlags memoryProperties) {
    uint32_t memoryType = 0;
    for (uint32_t memoryTypeIndex = 0; memoryTypeIndex < VK_MAX_MEMORY_TYPES; ++memoryTypeIndex) {
        if (memoryRequirements.memoryTypeBits & (1 << memoryTypeIndex)) {
            if ((gpuMemProps.memoryTypes[memoryTypeIndex].propertyFlags & memoryProperties) == memoryProperties) {
                memoryType = memoryTypeIndex;
                break;
            }
        }
    }

    return memoryType;
}

#ifdef WIN32
LRESULT CALLBACK wndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch (message)
    {
        case WM_SIZE:
        {
            int width = LOWORD(lParam);
            int height = HIWORD(lParam);
        } break;
        case WM_CLOSE: {
            PostQuitMessage(0);
            return 0;
        }
    }

    return DefWindowProc(hWnd, message, wParam, lParam);
}
#endif

#ifdef _DEBUG
VkBool32 VKAPI_PTR debug_callback(
        VkDebugUtilsMessageSeverityFlagBitsEXT           messageSeverity,
        VkDebugUtilsMessageTypeFlagsEXT                  /*messageTypes*/,
        const VkDebugUtilsMessengerCallbackDataEXT*      pCallbackData,
        void*                                            /*pUserData*/)
{
    std::string prefix;

    if (messageSeverity == VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT) {
        prefix += "WARNING";
    }
    else if (messageSeverity == VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT) {
        prefix += "ERROR";
    }

    if (pCallbackData) {
        printf("[%s] %s, %s\n", prefix.c_str(), pCallbackData->pMessageIdName, pCallbackData->pMessage);
    }

    return VK_FALSE;
}
#endif

int main() {

    CVulkanHelper::initVulkan();

    VkApplicationInfo appInfo = {};
    appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
    appInfo.apiVersion = VK_API_VERSION_1_2;
    appInfo.applicationVersion = VK_MAKE_VERSION(1,0,0);
    appInfo.pApplicationName = "Something";
    appInfo.engineVersion = VK_MAKE_VERSION(1,0,0);
    appInfo.pEngineName = "Cool Engine";

    uint32_t instanceLayerCount;
    vkEnumerateInstanceLayerProperties(&instanceLayerCount, nullptr);
    std::vector<VkLayerProperties> instanceLayers(instanceLayerCount);
    vkEnumerateInstanceLayerProperties(&instanceLayerCount, instanceLayers.data());

    uint32_t instanceExtensionCount;
    vkEnumerateInstanceExtensionProperties(nullptr, &instanceExtensionCount, nullptr);
    std::vector<VkExtensionProperties> instanceExtensions(instanceExtensionCount);
    vkEnumerateInstanceExtensionProperties(nullptr, &instanceExtensionCount, instanceExtensions.data());

    std::vector<const char*> enabledExtensions;
    enabledExtensions.push_back(VK_KHR_SURFACE_EXTENSION_NAME);

    for (size_t layer_index = 0; layer_index < instanceLayerCount; ++layer_index) {

        printf("Layer: %s, Spec Version: %d.%d.%d\n", instanceLayers[layer_index].layerName, 
                                                      (instanceLayers[layer_index].specVersion >> 22) & 0x3ff,
                                                      (instanceLayers[layer_index].specVersion >> 12) & 0x3ff,
                                                      (instanceLayers[layer_index].specVersion >> 0) & 0xfff);
    }

#ifdef WIN32
    enabledExtensions.push_back(VK_KHR_WIN32_SURFACE_EXTENSION_NAME);
#elif defined(__linux__)
    enabledExtensions.push_back(VK_KHR_XCB_SURFACE_EXTENSION_NAME);
#endif

#ifdef _DEBUG
   enabledExtensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
#endif
    //enabledExtensions.push_back(VK_EXT_DEBUG_REPORT_EXTENSION_NAME);
    enabledExtensions.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);

    std::vector<const char*> enableValidationLayers;
#ifdef _DEBUG
    enableValidationLayers.push_back("VK_LAYER_KHRONOS_validation");
#endif
    enableValidationLayers.push_back("VK_LAYER_LUNARG_monitor");

    VkInstanceCreateInfo instanceInfo = {};
    instanceInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
    instanceInfo.pApplicationInfo = &appInfo;
    instanceInfo.enabledExtensionCount = static_cast<uint32_t>(enabledExtensions.size());
    instanceInfo.ppEnabledExtensionNames = enabledExtensions.data();
    instanceInfo.enabledLayerCount = static_cast<uint32_t>(enableValidationLayers.size());
    instanceInfo.ppEnabledLayerNames = enableValidationLayers.data();


    VkInstance instance;
    VkResult res = vkCreateInstance(&instanceInfo, nullptr, &instance);
    if (res != VK_SUCCESS) {
        printf("vkCreateInstance failed\n");
    }

    CVulkanHelper::initVulkanInstanceFunctions(instance);

#ifdef _DEBUG
    VkDebugUtilsMessengerCreateInfoEXT debugMessengerInfo = {};
    debugMessengerInfo.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
    debugMessengerInfo.messageSeverity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT;
    debugMessengerInfo.messageType = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT;
    debugMessengerInfo.pfnUserCallback = debug_callback;

    PFN_vkCreateDebugUtilsMessengerEXT pfnCreateDebugUtilsMessengerEXT = (PFN_vkCreateDebugUtilsMessengerEXT)vkGetInstanceProcAddr(instance, "vkCreateDebugUtilsMessengerEXT");

    VkDebugUtilsMessengerEXT debugMessenger;
    pfnCreateDebugUtilsMessengerEXT(instance, &debugMessengerInfo, nullptr, &debugMessenger);
#endif

    VkPhysicalDevice gpu;

    uint32_t gpuCount;
    vkEnumeratePhysicalDevices(instance, &gpuCount, nullptr);
    std::vector<VkPhysicalDevice> gpus(gpuCount);
    vkEnumeratePhysicalDevices(instance, &gpuCount, gpus.data());

    gpu = gpus[0];

    uint32_t deviceLayerCount;
    vkEnumerateDeviceLayerProperties(gpu, &deviceLayerCount, nullptr);
    std::vector<VkLayerProperties> deviceLayers(deviceLayerCount);
    vkEnumerateDeviceLayerProperties(gpu, &deviceLayerCount, deviceLayers.data());

    uint32_t deviceExtensionCount;
    vkEnumerateDeviceExtensionProperties(gpu, nullptr, &deviceExtensionCount, nullptr);
    std::vector<VkExtensionProperties> deviceExtensions(deviceExtensionCount);
    vkEnumerateDeviceExtensionProperties(gpu, nullptr, &deviceExtensionCount, deviceExtensions.data());

    uint32_t queuePropertyCount;
    vkGetPhysicalDeviceQueueFamilyProperties(gpu, &queuePropertyCount, nullptr);
    std::vector<VkQueueFamilyProperties> queueProperties(queuePropertyCount);
    vkGetPhysicalDeviceQueueFamilyProperties(gpu, &queuePropertyCount, queueProperties.data());

    const float queuePriority = 1.0f;

    VkDeviceQueueCreateInfo queueCreateInfo = {};
    queueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
    queueCreateInfo.queueFamilyIndex = 0;
    queueCreateInfo.queueCount = 1;
    queueCreateInfo.pQueuePriorities = &queuePriority;

    std::vector<const char*> activatedDeviceExtensions;
    activatedDeviceExtensions.push_back(VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME);
    activatedDeviceExtensions.push_back(VK_KHR_SWAPCHAIN_EXTENSION_NAME);
    //activatedDeviceExtensions.push_back(VK_NV_RAY_TRACING_EXTENSION_NAME);
    activatedDeviceExtensions.push_back(VK_KHR_DEFERRED_HOST_OPERATIONS_EXTENSION_NAME);
    activatedDeviceExtensions.push_back(VK_KHR_PIPELINE_LIBRARY_EXTENSION_NAME);
    activatedDeviceExtensions.push_back(VK_KHR_ACCELERATION_STRUCTURE_EXTENSION_NAME);
    activatedDeviceExtensions.push_back(VK_KHR_RAY_TRACING_PIPELINE_EXTENSION_NAME);
    activatedDeviceExtensions.push_back(VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME);

    VkDevice device;

   // VkPhysicalDeviceDescriptorIndexingFeaturesEXT descriptorIndexingFeatures = {};
   // descriptorIndexingFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT;

    VkPhysicalDeviceAccelerationStructureFeaturesKHR accelerationStructureFeatures = {};
    accelerationStructureFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR;

    VkPhysicalDeviceRayTracingPipelineFeaturesKHR raytracingPipelineFeatures = {};
    raytracingPipelineFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR;
    raytracingPipelineFeatures.pNext = &accelerationStructureFeatures;

    VkPhysicalDeviceVulkan12Features vulkan12Features = {};
    vulkan12Features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES;
    vulkan12Features.pNext = &raytracingPipelineFeatures;

    VkPhysicalDeviceFeatures2 features2 = {};
    features2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
    features2.pNext = &vulkan12Features;
    vkGetPhysicalDeviceFeatures2(gpu, &features2);

    VkDeviceCreateInfo deviceCreateInfo = {};
    deviceCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
    deviceCreateInfo.pNext = &features2;
    deviceCreateInfo.pQueueCreateInfos = &queueCreateInfo;
    deviceCreateInfo.queueCreateInfoCount = 1;
    deviceCreateInfo.enabledExtensionCount = static_cast<uint32_t>(activatedDeviceExtensions.size());
    deviceCreateInfo.ppEnabledExtensionNames = activatedDeviceExtensions.data();

    res = vkCreateDevice(gpu, &deviceCreateInfo, nullptr, &device);
    if (res != VK_SUCCESS) {
        printf("vkCreateDevice failed\n");
    }

    CVulkanHelper::initVulkanDeviceFunctions(device);

    VkQueue queue;
    vkGetDeviceQueue(device, 0, 0, &queue);

    VkCommandPoolCreateInfo cmdPoolInfo = {};
    cmdPoolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
    cmdPoolInfo.queueFamilyIndex = 0;

    VkCommandPool commandPool;
    vkCreateCommandPool(device, &cmdPoolInfo, nullptr, &commandPool);

    VkPhysicalDeviceMemoryProperties gpuMemProps;
    vkGetPhysicalDeviceMemoryProperties(gpu, &gpuMemProps);

    std::vector<VkDescriptorPoolSize> poolSizes;

    VkDescriptorPoolSize poolSize0 = {};
    poolSize0.type = VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR;
    poolSize0.descriptorCount = 2;

    poolSizes.push_back(poolSize0);

    VkDescriptorPoolSize poolSize1 = {};
    poolSize1.type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
    poolSize1.descriptorCount = 2;

    poolSizes.push_back(poolSize1);

    VkDescriptorPoolSize poolSize2 = {};
    poolSize2.type = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE;
    poolSize2.descriptorCount = 2;

    poolSizes.push_back(poolSize2);

    VkDescriptorPoolSize poolSize3 = {};
    poolSize3.type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
    poolSize3.descriptorCount = 2;

    poolSizes.push_back(poolSize3);

    VkDescriptorPoolCreateInfo descriptorPoolInfo = {};
    descriptorPoolInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
    descriptorPoolInfo.maxSets = 3;
    descriptorPoolInfo.poolSizeCount = static_cast<uint32_t>(poolSizes.size());
    descriptorPoolInfo.pPoolSizes = poolSizes.data();

    VkDescriptorPool descriptorPool;
    vkCreateDescriptorPool(device, &descriptorPoolInfo, nullptr, &descriptorPool);

    VkPhysicalDeviceAccelerationStructurePropertiesKHR accelerationStructureProperties = {};
    accelerationStructureProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR;

    VkPhysicalDeviceRayTracingPipelinePropertiesKHR raytracingPipelineProperties = {};
    raytracingPipelineProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR;
    raytracingPipelineProperties.pNext = &accelerationStructureProperties;

    VkPhysicalDeviceProperties2 props = {};
    props.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
    props.pNext = &raytracingPipelineProperties;

    vkGetPhysicalDeviceProperties2(gpu, &props);

    CRayTracing rayTracing(instance, device, gpu, queue, commandPool, raytracingPipelineProperties);
    rayTracing.init();
    rayTracing.initScene();

    rayTracing.buildProceduralGeometryAABBs();
    rayTracing.buildTriangleAccelerationStructure();

    rayTracing.updateAABBPrimitivesAttributes(0.0f);

    std::vector<VkDescriptorSetLayoutBinding> layoutbindings;

    VkDescriptorSetLayoutBinding layoutbindingAccelerationStructure = {};
    layoutbindingAccelerationStructure.binding = 0;
    layoutbindingAccelerationStructure.descriptorType = VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR;
    layoutbindingAccelerationStructure.descriptorCount = 1;
    layoutbindingAccelerationStructure.stageFlags = VK_SHADER_STAGE_RAYGEN_BIT_KHR | VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR;

    layoutbindings.push_back(layoutbindingAccelerationStructure);

    VkDescriptorSetLayoutBinding layoutbindingOuputImage = {};
    layoutbindingOuputImage.binding = 1;
    layoutbindingOuputImage.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE;
    layoutbindingOuputImage.descriptorCount = 1;
    layoutbindingOuputImage.stageFlags = VK_SHADER_STAGE_RAYGEN_BIT_KHR;

    layoutbindings.push_back(layoutbindingOuputImage);

    VkDescriptorSetLayoutBinding layoutbindingSceneBuffer = {};
    layoutbindingSceneBuffer.binding = 2;
    layoutbindingSceneBuffer.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
    layoutbindingSceneBuffer.descriptorCount = 1;
    layoutbindingSceneBuffer.stageFlags = VK_SHADER_STAGE_RAYGEN_BIT_KHR | VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR | VK_SHADER_STAGE_INTERSECTION_BIT_KHR;

    layoutbindings.push_back(layoutbindingSceneBuffer);

    VkDescriptorSetLayoutBinding layoutbindingFacesBuffer = {};
    layoutbindingFacesBuffer.binding = 3;
    layoutbindingFacesBuffer.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
    layoutbindingFacesBuffer.descriptorCount = 1;
    layoutbindingFacesBuffer.stageFlags = VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR;

    layoutbindings.push_back(layoutbindingFacesBuffer);

    VkDescriptorSetLayoutBinding layoutbindingNormalBuffer = {};
    layoutbindingNormalBuffer.binding = 4;
    layoutbindingNormalBuffer.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
    layoutbindingNormalBuffer.descriptorCount = 1;
    layoutbindingNormalBuffer.stageFlags = VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR;

    layoutbindings.push_back(layoutbindingNormalBuffer);

    VkDescriptorSetLayoutBinding layoutbindingAABBPrimitiveBuffer = {};
    layoutbindingAABBPrimitiveBuffer.binding = 5;
    layoutbindingAABBPrimitiveBuffer.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
    layoutbindingAABBPrimitiveBuffer.descriptorCount = 1;
    layoutbindingAABBPrimitiveBuffer.stageFlags = VK_SHADER_STAGE_RAYGEN_BIT_KHR | VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR | VK_SHADER_STAGE_INTERSECTION_BIT_KHR;

    layoutbindings.push_back(layoutbindingAABBPrimitiveBuffer);

    VkDescriptorSetLayoutCreateInfo layoutInfo = {};
    layoutInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
    layoutInfo.bindingCount = static_cast<uint32_t>(layoutbindings.size());
    layoutInfo.pBindings = layoutbindings.data();

    std::vector<VkDescriptorSetLayout> descriptorSetLayouts;

    VkDescriptorSetLayout descriptorSetLayout;
    vkCreateDescriptorSetLayout(device, &layoutInfo, nullptr, &descriptorSetLayout);

    descriptorSetLayouts.push_back(descriptorSetLayout);

    rayTracing.createShaderStages();

    //std::vector<VkRayTracingShaderGroupCreateInfoNV> const& shaderGroups = rayTracing.createShaderGroups();

    VkDescriptorSetAllocateInfo descriptorSetAllocInfo = {};
    descriptorSetAllocInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
    descriptorSetAllocInfo.descriptorSetCount = static_cast<uint32_t>(descriptorSetLayouts.size());
    descriptorSetAllocInfo.pSetLayouts = descriptorSetLayouts.data();
    descriptorSetAllocInfo.descriptorPool = descriptorPool;

    VkDescriptorSet descriptorSet;
    vkAllocateDescriptorSets(device, &descriptorSetAllocInfo, &descriptorSet);

    VkPipelineLayoutCreateInfo pipelineLayoutInfo ={};
    pipelineLayoutInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
    pipelineLayoutInfo.setLayoutCount = 1;
    pipelineLayoutInfo.pSetLayouts = &descriptorSetLayout;

    VkPipelineLayout pipelineLayout;
    res = vkCreatePipelineLayout(device, &pipelineLayoutInfo, nullptr, &pipelineLayout);
    if (res != VK_SUCCESS) {
        printf("vkCreatePipelineLayout failed\n");
    }

    VkPipeline raytracingPipeline = rayTracing.createPipeline(pipelineLayout);

    const char* applicationName = "Vulkan Raytracing Example";

    VkSurfaceKHR surface;
#ifdef WIN32


    DWORD dwExStyle = WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;

    HINSTANCE hInstance = GetModuleHandle(NULL);

    WNDCLASSEX windowClass;
    windowClass.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
    windowClass.lpfnWndProc = (WNDPROC)wndProc;
    windowClass.cbClsExtra = 0;
    windowClass.cbWndExtra = 0;
    windowClass.hInstance = hInstance;
    windowClass.hIcon = LoadIcon(NULL, IDI_WINLOGO);
    windowClass.hIconSm = windowClass.hIcon;
    windowClass.hCursor = LoadCursor(NULL, IDC_ARROW);
    windowClass.hbrBackground = NULL;
    windowClass.lpszMenuName = NULL;
    windowClass.lpszClassName = applicationName;
    windowClass.cbSize = sizeof(WNDCLASSEX);

    RegisterClassEx(&windowClass);

    RECT winRect = { 0, 0, WIDTH, HEIGHT };
    AdjustWindowRect(&winRect, WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX, FALSE);

    HWND hWnd = CreateWindowEx(dwExStyle, applicationName, applicationName, WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX, CW_USEDEFAULT, 0, winRect.right - winRect.left, winRect.bottom - winRect.top, NULL, NULL, hInstance, NULL);
    //SetWindowLongPtr(m_hWnd, GWLP_USERDATA, (LONG_PTR)this);
    ShowWindow(hWnd, SW_SHOW);
    SetForegroundWindow(hWnd);
    SetFocus(hWnd);

    VkWin32SurfaceCreateInfoKHR surfaceCreateInfo = {};
    surfaceCreateInfo.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
    surfaceCreateInfo.hinstance = hInstance;
    surfaceCreateInfo.hwnd = hWnd;
    vkCreateWin32SurfaceKHR(instance, &surfaceCreateInfo, nullptr, &surface);
#elif defined(__linux__)
    int screenp = 0;
    xcb_connection_t* connection = xcb_connect(nullptr, &screenp);
    if (xcb_connection_has_error(connection)) {
        printf("Failed to connect to X server using XCB.\n");
    }

    xcb_screen_iterator_t iter = xcb_setup_roots_iterator(xcb_get_setup(connection));

    for (int s = screenp; s > 0; --s) {
        xcb_screen_next(&iter);
    }

    xcb_screen_t* screen = iter.data;

    xcb_window_t window = xcb_generate_id(connection);

    uint32_t eventMask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;
    uint32_t valueList[] = { screen->black_pixel, 0 };

    xcb_create_window(connection, XCB_COPY_FROM_PARENT, window, screen->root, 0, 0, WIDTH, HEIGHT, 0, XCB_WINDOW_CLASS_INPUT_OUTPUT, screen->root_visual, eventMask, valueList);

    VkXcbSurfaceCreateInfoKHR surfaceCreateInfo = {};
    surfaceCreateInfo.sType = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR;
    surfaceCreateInfo.window = window;
    surfaceCreateInfo.connection = connection;

    vkCreateXcbSurfaceKHR(instance, &surfaceCreateInfo, nullptr, &surface);
#endif

    VkBool32 queueSupported;
    vkGetPhysicalDeviceSurfaceSupportKHR(gpu, 0, surface, &queueSupported);

    uint32_t formatCount;
    vkGetPhysicalDeviceSurfaceFormatsKHR(gpu, surface, &formatCount, nullptr);
    std::vector<VkSurfaceFormatKHR> surfaceFormats(formatCount);
    vkGetPhysicalDeviceSurfaceFormatsKHR(gpu, surface, &formatCount, surfaceFormats.data());

    VkBool32 presentSupport = VK_FALSE;
    vkGetPhysicalDeviceSurfaceSupportKHR(gpu, 0, surface, &presentSupport);

    VkQueue presentQueue = VK_NULL_HANDLE;
    vkGetDeviceQueue(device, 0, 0, &presentQueue);

    VkSurfaceCapabilitiesKHR capabilities;
    vkGetPhysicalDeviceSurfaceCapabilitiesKHR(gpu, surface, &capabilities);

    uint32_t presentModeCount;
    vkGetPhysicalDeviceSurfacePresentModesKHR(gpu, surface, &presentModeCount, nullptr);
    std::vector<VkPresentModeKHR> presentModes(presentModeCount);
    vkGetPhysicalDeviceSurfacePresentModesKHR(gpu, surface, &presentModeCount, presentModes.data());

    VkSurfaceFormatKHR surfaceFormat;

    if (surfaceFormats.size() == 1 && surfaceFormats[0].format == VK_FORMAT_UNDEFINED) {
        surfaceFormat = { VK_FORMAT_B8G8R8A8_UNORM, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR };
    }
    else {
        for (size_t formatIndex = 0; formatIndex < surfaceFormats.size(); ++formatIndex) {
            if (surfaceFormats[formatIndex].format == VK_FORMAT_B8G8R8A8_UNORM && surfaceFormats[formatIndex].colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR) {
                surfaceFormat = surfaceFormats[formatIndex];
                break;
            }
        }
    }

    VkPresentModeKHR presentMode = VK_PRESENT_MODE_FIFO_KHR;;
    
#ifndef VSYNC
    for (size_t presentModeIndex = 0; presentModeIndex < presentModes.size(); ++presentModeIndex) {
        if (presentModes[presentModeIndex] == VK_PRESENT_MODE_MAILBOX_KHR) {
            presentMode = presentModes[presentModeIndex];
            break;
        }
        else if (presentModes[presentModeIndex] == VK_PRESENT_MODE_IMMEDIATE_KHR) {
            presentMode = presentModes[presentModeIndex];
        }
    }
#endif
    
    VkExtent2D swapExtent;

    if (capabilities.currentExtent.width != std::numeric_limits<uint32_t>::max()) {
        swapExtent = capabilities.currentExtent;
    }
    else {
        swapExtent = { WIDTH, HEIGHT };
        swapExtent.width = std::max(capabilities.minImageExtent.width, std::min(capabilities.maxImageExtent.width, swapExtent.width));
        swapExtent.height = std::max(capabilities.minImageExtent.height, std::min(capabilities.maxImageExtent.height, swapExtent.height));
    }

    uint32_t imageCount = capabilities.minImageCount + 1;
    if (capabilities.maxImageCount > 0 && imageCount > capabilities.maxImageCount) {
        imageCount = capabilities.maxImageCount;
    }

    VkSwapchainCreateInfoKHR swapChainInfo = {};
    swapChainInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
    swapChainInfo.surface = surface;
    swapChainInfo.minImageCount = imageCount;
    swapChainInfo.imageFormat = surfaceFormat.format;
    swapChainInfo.imageColorSpace = surfaceFormat.colorSpace;
    swapChainInfo.imageExtent = swapExtent;
    swapChainInfo.imageArrayLayers = 1;
    swapChainInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
    swapChainInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
    swapChainInfo.queueFamilyIndexCount = 0;
    swapChainInfo.pQueueFamilyIndices = nullptr;
    swapChainInfo.preTransform = capabilities.currentTransform;
    swapChainInfo.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
    swapChainInfo.presentMode = presentMode;
    swapChainInfo.clipped = VK_TRUE;
    swapChainInfo.oldSwapchain = VK_NULL_HANDLE;

    VkSwapchainKHR swapchain;
    vkCreateSwapchainKHR(device, &swapChainInfo, nullptr, &swapchain);

    uint32_t swapImageCount;
    vkGetSwapchainImagesKHR(device, swapchain, &swapImageCount, nullptr);
    std::vector<VkImage> swapImages(swapImageCount);
    vkGetSwapchainImagesKHR(device, swapchain, &swapImageCount, swapImages.data());

    std::vector<VkImageView> swapImageViews(swapImageCount);

    for (size_t swapImageIndex = 0; swapImageIndex < swapImages.size(); ++swapImageIndex) {
        VkImageViewCreateInfo imageViewInfo = {};
        imageViewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
        imageViewInfo.image = swapImages[swapImageIndex];
        imageViewInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
        imageViewInfo.format = surfaceFormat.format;
        imageViewInfo.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;
        imageViewInfo.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;
        imageViewInfo.components.b = VK_COMPONENT_SWIZZLE_IDENTITY;
        imageViewInfo.components.a = VK_COMPONENT_SWIZZLE_IDENTITY;
        imageViewInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
        imageViewInfo.subresourceRange.baseMipLevel = 0;
        imageViewInfo.subresourceRange.levelCount = 1;
        imageViewInfo.subresourceRange.baseArrayLayer = 0;
        imageViewInfo.subresourceRange.layerCount = 1;

        vkCreateImageView(device, &imageViewInfo, nullptr, &swapImageViews[swapImageIndex]);
    }

    rayTracing.createSceneBuffer();
    rayTracing.updateSceneBuffer();
    rayTracing.createAABBPrimitiveBuffer();
    rayTracing.updateAABBPrimitiveBuffer();

    VulkanImage offscreenImage = rayTracing.createOffscreenImage(surfaceFormat.format, swapExtent.width, swapExtent.height);

    rayTracing.updateDescriptors(descriptorSet);

    VkAttachmentDescription colorAttachment = {};
    colorAttachment.format = surfaceFormat.format;
    colorAttachment.samples = VK_SAMPLE_COUNT_1_BIT;
    colorAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
    colorAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
    colorAttachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
    colorAttachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
    colorAttachment.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
    colorAttachment.finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;

    VkAttachmentReference colorAttachmentRef = {};
    colorAttachmentRef.attachment = 0;
    colorAttachmentRef.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;

    VkSubpassDescription subpass = {};
    subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
    subpass.colorAttachmentCount = 1;
    subpass.pColorAttachments = &colorAttachmentRef;

    VkRenderPassCreateInfo renderpassInfo = {};
    renderpassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
    renderpassInfo.attachmentCount = 1;
    renderpassInfo.pAttachments = &colorAttachment;
    renderpassInfo.subpassCount = 1;
    renderpassInfo.pSubpasses = &subpass;

    VkRenderPass renderpass;
    vkCreateRenderPass(device, &renderpassInfo, nullptr, &renderpass);

    std::vector<VkFramebuffer> swapFramebuffers(swapImageCount);

    for (size_t frameBufferIndex = 0; frameBufferIndex < swapFramebuffers.size(); ++frameBufferIndex) {
        VkImageView attachments[] = {
          swapImageViews[frameBufferIndex]
        };

        VkFramebufferCreateInfo frameBufferInfo = {};
        frameBufferInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
        frameBufferInfo.renderPass = renderpass;
        frameBufferInfo.attachmentCount = 1;
        frameBufferInfo.pAttachments = attachments;
        frameBufferInfo.width = swapExtent.width;
        frameBufferInfo.height = swapExtent.height;
        frameBufferInfo.layers = 1;

        vkCreateFramebuffer(device, &frameBufferInfo, nullptr, &swapFramebuffers[frameBufferIndex]);
    }

    std::vector<VkCommandBuffer> commandBuffers(swapFramebuffers.size());

    VkCommandBufferAllocateInfo cmdBufferAllocInfo = {};
    cmdBufferAllocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
    cmdBufferAllocInfo.commandPool = commandPool;
    cmdBufferAllocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
    cmdBufferAllocInfo.commandBufferCount = static_cast<uint32_t>(commandBuffers.size());
    vkAllocateCommandBuffers(device, &cmdBufferAllocInfo, commandBuffers.data());

    VulkanBuffer raygenShaderGroup = rayTracing.getRayGenShaderGroups();
    VkStridedDeviceAddressRegionKHR raygenStridedBufferRegion = {};
    raygenStridedBufferRegion.deviceAddress = raygenShaderGroup.address;
    raygenStridedBufferRegion.stride = raytracingPipelineProperties.shaderGroupHandleSize;
    raygenStridedBufferRegion.size = raytracingPipelineProperties.shaderGroupHandleSize;
    
    uint32_t raygenAlignment = CVulkanHelper::alignTo(raytracingPipelineProperties.shaderGroupHandleSize, raytracingPipelineProperties.shaderGroupBaseAlignment);

    VkStridedDeviceAddressRegionKHR missStridedBufferRegion = {};
    missStridedBufferRegion.deviceAddress = raygenShaderGroup.address + raygenAlignment;
    missStridedBufferRegion.stride = raytracingPipelineProperties.shaderGroupHandleSize;
    missStridedBufferRegion.size = raytracingPipelineProperties.shaderGroupHandleSize * 2;

    uint32_t missAlignment = CVulkanHelper::alignTo(raytracingPipelineProperties.shaderGroupHandleSize * 2, raytracingPipelineProperties.shaderGroupBaseAlignment);

    VkStridedDeviceAddressRegionKHR hitStridedBufferRegion = {};
    hitStridedBufferRegion.deviceAddress = raygenShaderGroup.address + raygenAlignment + missAlignment;
    hitStridedBufferRegion.stride = (raytracingPipelineProperties.shaderGroupHandleSize + sizeof(PrimitiveConstantBuffer) + sizeof(PrimitiveInstanceConstantBuffer));
    hitStridedBufferRegion.size = (raytracingPipelineProperties.shaderGroupHandleSize + sizeof(PrimitiveConstantBuffer) + sizeof(PrimitiveInstanceConstantBuffer)) * 10;

    VkStridedDeviceAddressRegionKHR callableStridedBufferRegion = {};

    for (size_t commandBufferIndex = 0; commandBufferIndex < commandBuffers.size(); ++commandBufferIndex) {

        VkCommandBufferBeginInfo beginInfo = {};
        beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
        beginInfo.flags = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT;

        vkBeginCommandBuffer(commandBuffers[commandBufferIndex], &beginInfo);

        VkImageSubresourceRange subresourceRange = {};
        subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
        subresourceRange.baseMipLevel = 0;
        subresourceRange.levelCount = 1;
        subresourceRange.baseArrayLayer = 0;
        subresourceRange.layerCount = 1;

        VkImageMemoryBarrier imageMemoryBarrier {};
        imageMemoryBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
        imageMemoryBarrier.srcAccessMask = 0;
        imageMemoryBarrier.dstAccessMask = VK_ACCESS_SHADER_WRITE_BIT;
        imageMemoryBarrier.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED;
        imageMemoryBarrier.newLayout = VK_IMAGE_LAYOUT_GENERAL;
        imageMemoryBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
        imageMemoryBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
        imageMemoryBarrier.image = offscreenImage.handle;
        imageMemoryBarrier.subresourceRange = subresourceRange;

        vkCmdPipelineBarrier(commandBuffers[commandBufferIndex], VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, 0, nullptr, 0, nullptr, 1, &imageMemoryBarrier);

        vkCmdBindPipeline(commandBuffers[commandBufferIndex], VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR, raytracingPipeline);
        vkCmdBindDescriptorSets(commandBuffers[commandBufferIndex], VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR, pipelineLayout, 0, 1, &descriptorSet, 0, nullptr);

        vkCmdTraceRaysKHR(commandBuffers[commandBufferIndex],
                       &raygenStridedBufferRegion,
                       &missStridedBufferRegion,
                       &hitStridedBufferRegion,
                       &callableStridedBufferRegion,
                       WIDTH, HEIGHT, 1);

        imageMemoryBarrier.srcAccessMask = 0;
        imageMemoryBarrier.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
        imageMemoryBarrier.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED;
        imageMemoryBarrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
        imageMemoryBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
        imageMemoryBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
        imageMemoryBarrier.image = swapImages[commandBufferIndex];
        imageMemoryBarrier.subresourceRange = subresourceRange;
        vkCmdPipelineBarrier(commandBuffers[commandBufferIndex], VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 0, nullptr, 1, &imageMemoryBarrier);

        imageMemoryBarrier.srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT;
        imageMemoryBarrier.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
        imageMemoryBarrier.oldLayout = VK_IMAGE_LAYOUT_GENERAL;
        imageMemoryBarrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
        imageMemoryBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
        imageMemoryBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
        imageMemoryBarrier.image = offscreenImage.handle;
        imageMemoryBarrier.subresourceRange = subresourceRange;
        vkCmdPipelineBarrier(commandBuffers[commandBufferIndex], VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 0, nullptr, 1, &imageMemoryBarrier);

        VkImageCopy copyRegion;
        copyRegion.srcSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1 };
        copyRegion.srcOffset = { 0, 0, 0 };
        copyRegion.dstSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1 };
        copyRegion.dstOffset = { 0, 0, 0 };
        copyRegion.extent = {swapExtent.width, swapExtent.height, 1};
        vkCmdCopyImage(commandBuffers[commandBufferIndex], offscreenImage.handle, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, swapImages[commandBufferIndex], VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &copyRegion);

        imageMemoryBarrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
        imageMemoryBarrier.dstAccessMask = 0;
        imageMemoryBarrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
        imageMemoryBarrier.newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
        imageMemoryBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
        imageMemoryBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
        imageMemoryBarrier.image = swapImages[commandBufferIndex];
        imageMemoryBarrier.subresourceRange = subresourceRange;
        vkCmdPipelineBarrier(commandBuffers[commandBufferIndex], VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, 0, nullptr, 0, nullptr, 1, &imageMemoryBarrier);

        vkEndCommandBuffer(commandBuffers[commandBufferIndex]);
    }

    VkSemaphoreCreateInfo semaphoreInfo = {};
    semaphoreInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;

    std::vector<VkSemaphore> imageAvailableSemaphores(swapImageCount);
    for (size_t index = 0; index < imageAvailableSemaphores.size(); ++index) {
        vkCreateSemaphore(device, &semaphoreInfo, nullptr, &imageAvailableSemaphores[index]);
    }

    std::vector<VkSemaphore> renderFinishedSemaphores(swapImageCount);
    for (size_t index = 0; index < renderFinishedSemaphores.size(); ++index) {
        vkCreateSemaphore(device, &semaphoreInfo, nullptr, &renderFinishedSemaphores[index]);
    }

    VkFenceCreateInfo fenceCreateInfo = {};
    fenceCreateInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
    fenceCreateInfo.flags = VK_FENCE_CREATE_SIGNALED_BIT;

    std::vector<VkFence> fences(swapImageCount);
    for (uint32_t fenceIndex = 0; fenceIndex < fences.size(); ++fenceIndex) {
        vkCreateFence(device, &fenceCreateInfo, nullptr, &fences[fenceIndex]);
    }

    bool running = true;

#ifdef WIN32
#elif defined(__linux__)
    xcb_change_property(connection, XCB_PROP_MODE_REPLACE, window, XCB_ATOM_WM_NAME, XCB_ATOM_STRING, 8, static_cast<uint32_t>(strlen(applicationName)), applicationName);

    xcb_intern_atom_cookie_t wmDeleteCookie = xcb_intern_atom(connection, 0, strlen("WM_DELETE_WINDOW"), "WM_DELETE_WINDOW");
    xcb_intern_atom_cookie_t wmProtocolsCookie = xcb_intern_atom(connection, 0, strlen("WM_PROTOCOLS"), "WM_PROTOCOLS");
    xcb_intern_atom_reply_t *wmDeleteReply = xcb_intern_atom_reply(connection, wmDeleteCookie, nullptr);
    xcb_intern_atom_reply_t *wmProtocolReply = xcb_intern_atom_reply(connection, wmProtocolsCookie, nullptr);

    xcb_atom_t wmDeleteWin = wmDeleteReply->atom;
    xcb_change_property(connection, XCB_PROP_MODE_REPLACE, window, wmProtocolReply->atom, 4, 32, 1, &wmDeleteReply->atom);

    xcb_map_window(connection, window);
    xcb_flush(connection);

    xcb_generic_event_t *event;
    xcb_client_message_event_t *cm;
#endif

    uint32_t frameIndex = 0;

    while (running) {
#ifdef WIN32
        MSG msg;
        while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }

        if (msg.message == WM_QUIT) {
            running = false;
        }
#elif defined(__linux__)
        while ((event = xcb_poll_for_event(connection)) != nullptr) {
            switch (event->response_type & ~0x80) {
                case XCB_CLIENT_MESSAGE: {
                    cm = reinterpret_cast<xcb_client_message_event_t*>(event);
                    if (cm->data.data32[0] == wmDeleteWin) {
                        running = false;
                    }
                } break;
            }
            free(event);
        }
#endif
        rayTracing.update();

        uint32_t imageIndex;
        vkAcquireNextImageKHR(device, swapchain, std::numeric_limits<uint64_t>::max(), imageAvailableSemaphores[frameIndex], VK_NULL_HANDLE, &imageIndex);

        VkPipelineStageFlags waitStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;

        VkSubmitInfo submitInfo = {};
        submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
        submitInfo.waitSemaphoreCount = 1;
        submitInfo.pWaitSemaphores = &imageAvailableSemaphores[frameIndex];
        submitInfo.pWaitDstStageMask = &waitStageMask;
        submitInfo.commandBufferCount = 1;
        submitInfo.pCommandBuffers = &commandBuffers[frameIndex];
        submitInfo.signalSemaphoreCount = 1;
        submitInfo.pSignalSemaphores = &renderFinishedSemaphores[frameIndex];

        VkFence fence = fences[frameIndex];
        vkWaitForFences(device, 1, &fence, VK_TRUE, UINT64_MAX);
        vkResetFences(device, 1, &fence);

        vkQueueSubmit(queue, 1, &submitInfo, fence);

        VkPresentInfoKHR presentInfo = {};
        presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
        presentInfo.waitSemaphoreCount = 1;
        presentInfo.pWaitSemaphores = &renderFinishedSemaphores[frameIndex];
        presentInfo.swapchainCount = 1;
        presentInfo.pSwapchains = &swapchain;
        presentInfo.pImageIndices = &imageIndex;

        vkQueuePresentKHR(queue, &presentInfo);

        frameIndex = (frameIndex + 1) % swapImageCount;
    }

#ifdef WIN32
#elif defined(__linux__)
    xcb_destroy_window(connection, window);
#endif

    return 0;
}