/*
* Copyright (C) 2017 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

#include "DeviceImpl.h"
#include "QueueImpl.h"
#include "RenderStateImpl.h"
#include "ComputeStateImpl.h"
#include "QueueImpl.h"
#include <cassert>
#include <limits>
#include <sstream>

namespace WebGPU {
    static const vk::Format framebufferColorPixelFormat = vk::Format::eR8G8B8A8Srgb;

    std::unique_ptr<Device> Device::create(HINSTANCE hInstance, HWND hWnd) {
        return std::unique_ptr<Device>(new DeviceImpl(hInstance, hWnd));
    }

    static vk::Format convertPixelFormat(PixelFormat pixelFormat) {
        switch (pixelFormat) {
        case PixelFormat::RGBA8sRGB:
            return vk::Format::eR8G8B8A8Srgb;
        case PixelFormat::RGBA8:
            return vk::Format::eR8G8B8A8Unorm;
        default:
            assert(false);
            return vk::Format::eR8G8B8A8Unorm;
        }
    }

    static PixelFormat convertFormat(vk::Format format) {
        switch (format) {
        case vk::Format::eR8G8B8A8Srgb:
            return PixelFormat::RGBA8sRGB;
        case vk::Format::eR8G8B8A8Unorm:
            return PixelFormat::RGBA8;
        default:
            assert(false);
            return PixelFormat::RGBA8;
        }
    }

    static VkBool32 debugReport(VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage, void* pUserData) {
        vk::DebugReportFlagsEXT flagsObject = static_cast<vk::DebugReportFlagBitsEXT>(flags);
        vk::DebugReportObjectTypeEXT objectTypeObject = static_cast<vk::DebugReportObjectTypeEXT>(objectType);
        std::ostringstream ss;
        ss << "Vulkan Log: " << vk::to_string(flagsObject) << " " << vk::to_string(objectTypeObject) << " " << object << " " << location << " " << messageCode << " " << std::string(pLayerPrefix) << " " << std::string(pMessage) << std::endl;
        OutputDebugStringA(ss.str().c_str());
        return VK_FALSE;
    }

    DeviceImpl::DeviceImpl(HINSTANCE hInstance, HWND hWnd) {
        auto layerProperties = vk::enumerateInstanceLayerProperties();
        auto const app = vk::ApplicationInfo()
            .setPApplicationName("WebGPU")
            .setApplicationVersion(0)
            .setPEngineName("WebGPU")
            .setEngineVersion(0)
            .setApiVersion(VK_API_VERSION_1_0);
        const char* const instanceValidationLayers[] = { "VK_LAYER_LUNARG_standard_validation", "VK_LAYER_GOOGLE_threading", "VK_LAYER_LUNARG_parameter_validation", "VK_LAYER_LUNARG_object_tracker", "VK_LAYER_LUNARG_core_validation", "VK_LAYER_GOOGLE_unique_objects" };
        const char* const instanceExtensionNames[] = { VK_KHR_SURFACE_EXTENSION_NAME, VK_KHR_WIN32_SURFACE_EXTENSION_NAME, VK_EXT_DEBUG_REPORT_EXTENSION_NAME };
        const auto debugReportCallbackCreateInfo = vk::DebugReportCallbackCreateInfoEXT()
            .setFlags(vk::DebugReportFlagBitsEXT::eInformation | vk::DebugReportFlagBitsEXT::eWarning | vk::DebugReportFlagBitsEXT::ePerformanceWarning | vk::DebugReportFlagBitsEXT::eError | vk::DebugReportFlagBitsEXT::eDebug)
            .setPfnCallback(&debugReport);
        const auto instanceInfo = vk::InstanceCreateInfo()
            .setPNext(&debugReportCallbackCreateInfo)
            .setPApplicationInfo(&app)
            .setEnabledLayerCount(1)
            .setPpEnabledLayerNames(instanceValidationLayers)
            .setEnabledExtensionCount(3)
            .setPpEnabledExtensionNames(instanceExtensionNames);
        instance = vk::createInstanceUnique(instanceInfo);

        debugReportCallback = UniqueDebugReportCallbackEXT(*instance, debugReportCallbackCreateInfo);

        auto devices = instance->enumeratePhysicalDevices();
        gpu = devices[0];

        auto const surfaceCreateInfo = vk::Win32SurfaceCreateInfoKHR().setHinstance(hInstance).setHwnd(hWnd);
        surface = instance->createWin32SurfaceKHRUnique(surfaceCreateInfo);

        auto surfaceCapabilities = gpu.getSurfaceCapabilitiesKHR(*surface);

        auto queueFamilyProperties = gpu.getQueueFamilyProperties();

        bool foundQueueIndex = false;
        uint32_t queueFamilyIndex;
        for (uint32_t i = 0; i < queueFamilyProperties.size(); ++i) {
            bool supportsPresent = gpu.getSurfaceSupportKHR(i, *surface);
            auto& queueFamilyProperty = queueFamilyProperties[i];
            if (supportsPresent && (queueFamilyProperty.queueFlags & vk::QueueFlagBits::eGraphics) && (queueFamilyProperty.queueFlags & vk::QueueFlagBits::eCompute) && (queueFamilyProperty.queueFlags & vk::QueueFlagBits::eTransfer)) {
                queueFamilyIndex = i;
                foundQueueIndex = true;
                break;
            }
        }
        assert(foundQueueIndex);

        float priority = 0.0;
        vk::DeviceQueueCreateInfo queueCreateInfo;
        queueCreateInfo.setQueueFamilyIndex(queueFamilyIndex);
        queueCreateInfo.setQueueCount(1);
        queueCreateInfo.setPQueuePriorities(&priority);
        char const *deviceExtensionNames[1] = { VK_KHR_SWAPCHAIN_EXTENSION_NAME };
        auto deviceCreateInfo = vk::DeviceCreateInfo()
            .setQueueCreateInfoCount(1)
            .setPQueueCreateInfos(&queueCreateInfo)
            .setEnabledLayerCount(0)
            .setPpEnabledLayerNames(nullptr)
            .setEnabledExtensionCount(1)
            .setPpEnabledExtensionNames(deviceExtensionNames)
            .setPEnabledFeatures(nullptr);
        device = gpu.createDeviceUnique(deviceCreateInfo);

        const auto commandPoolCreateInfo = vk::CommandPoolCreateInfo().setQueueFamilyIndex(queueFamilyIndex);
        commandPool = device->createCommandPoolUnique(commandPoolCreateInfo);

        memoryProperties = gpu.getMemoryProperties();

        const auto swapchainCreateInfo = vk::SwapchainCreateInfoKHR()
            .setSurface(*surface)
            .setMinImageCount(3)
            .setImageFormat(framebufferColorPixelFormat)
            .setImageColorSpace(vk::ColorSpaceKHR::eSrgbNonlinear)
            .setImageExtent({ surfaceCapabilities.currentExtent.width, surfaceCapabilities.currentExtent.height })
            .setImageArrayLayers(1)
            .setImageUsage(vk::ImageUsageFlagBits::eColorAttachment)
            .setImageSharingMode(vk::SharingMode::eExclusive)
            .setQueueFamilyIndexCount(0)
            .setPQueueFamilyIndices(nullptr)
            .setPreTransform(vk::SurfaceTransformFlagBitsKHR::eIdentity)
            .setCompositeAlpha(vk::CompositeAlphaFlagBitsKHR::eOpaque)
            .setPresentMode(vk::PresentModeKHR::eFifo)
            .setClipped(true);
        swapchain = device->createSwapchainKHRUnique(swapchainCreateInfo);

        swapchainImages = device->getSwapchainImagesKHR(*swapchain);
        for (auto& swapchainImage : swapchainImages) {
            auto imageViewCreateInfo = vk::ImageViewCreateInfo()
                .setViewType(vk::ImageViewType::e2D)
                .setFormat(framebufferColorPixelFormat)
                .setSubresourceRange(vk::ImageSubresourceRange(vk::ImageAspectFlagBits::eColor, 0, 1, 0, 1))
                .setImage(swapchainImage);
            swapchainImageViews.push_back(device->createImageViewUnique(imageViewCreateInfo));
        }

        queue = std::unique_ptr<QueueImpl>(new QueueImpl(*device, *commandPool, swapchainImageViews, *swapchain, surfaceCapabilities.currentExtent, framebufferColorPixelFormat, device->getQueue(queueFamilyIndex, 0)));

        vk::PipelineCacheCreateInfo pipelineCacheCreateInfo;
        pipelineCache = device->createPipelineCacheUnique(pipelineCacheCreateInfo);
    }

    Queue& DeviceImpl::getCommandQueue() {
        return *queue;
    }

    vk::UniqueShaderModule DeviceImpl::prepareShader(const std::vector<uint8_t>& shader) {
        auto const moduleCreateInfo = vk::ShaderModuleCreateInfo().setCodeSize(shader.size()).setPCode(reinterpret_cast<const uint32_t*>(shader.data()));
        return device->createShaderModuleUnique(moduleCreateInfo);
    }

    std::pair<vk::UniquePipelineLayout, std::vector<vk::UniqueDescriptorSetLayout>> DeviceImpl::createPipelineLayout(const std::vector<std::vector<ResourceType>>& resources) {
        std::vector<vk::UniqueDescriptorSetLayout> descriptorSetLayouts;
        for (auto& resourceSet : resources) {
            std::vector<vk::DescriptorSetLayoutBinding> bindings;
            for (std::size_t i = 0; i < resourceSet.size(); ++i) {
                vk::DescriptorType descriptorType;
                switch (resourceSet[i]) {
                case ResourceType::Texture:
                    descriptorType = vk::DescriptorType::eSampledImage;
                    break;
                case ResourceType::Sampler:
                    descriptorType = vk::DescriptorType::eSampler;
                    break;
                case ResourceType::UniformBufferObject:
                    descriptorType = vk::DescriptorType::eUniformBuffer;
                    break;
                case ResourceType::ShaderStorageBufferObject:
                    descriptorType = vk::DescriptorType::eStorageBuffer;
                    break;
                }
                // Keep this in sync with RenderPassImpl::setResources().
                bindings.emplace_back(vk::DescriptorSetLayoutBinding().setBinding(static_cast<uint32_t>(i)).setDescriptorType(descriptorType).setDescriptorCount(1).setStageFlags(vk::ShaderStageFlagBits::eAll));
            }
            const auto descriptorSetLayoutCreateInfo = vk::DescriptorSetLayoutCreateInfo().setBindingCount(static_cast<uint32_t>(resourceSet.size())).setPBindings(bindings.data());
            descriptorSetLayouts.emplace_back(device->createDescriptorSetLayoutUnique(descriptorSetLayoutCreateInfo));
        }
        std::vector<vk::DescriptorSetLayout> weakDescriptorSetLayouts;
        for (auto& descriptorSetLayout : descriptorSetLayouts)
            weakDescriptorSetLayouts.push_back(*descriptorSetLayout);
        const auto pipelineLayoutCreateInfo = vk::PipelineLayoutCreateInfo().setSetLayoutCount(static_cast<uint32_t>(weakDescriptorSetLayouts.size())).setPSetLayouts(weakDescriptorSetLayouts.data());
        auto pipelineLayout = device->createPipelineLayoutUnique(pipelineLayoutCreateInfo);
        return std::make_pair(std::move(pipelineLayout), std::move(descriptorSetLayouts));
    }

    vk::UniqueRenderPass DeviceImpl::createCompatibleRenderPass(const std::vector<PixelFormat>* colorPixelFormats) {
        std::vector<vk::AttachmentDescription> attachmentDescriptions;
        std::vector<vk::AttachmentReference> attachmentReferences;

        if (colorPixelFormats == nullptr) {
            attachmentDescriptions.emplace_back(vk::AttachmentDescription().setFormat(framebufferColorPixelFormat).setSamples(vk::SampleCountFlagBits::e1));
            attachmentReferences.emplace_back(vk::AttachmentReference().setAttachment(0));
        }
        else {
            for (std::size_t i = 0; i < colorPixelFormats->size(); ++i) {
                vk::Format format = convertPixelFormat((*colorPixelFormats)[i]);
                attachmentDescriptions.emplace_back(vk::AttachmentDescription().setFormat(format).setSamples(vk::SampleCountFlagBits::e1));
                attachmentReferences.emplace_back(vk::AttachmentReference().setAttachment(static_cast<uint32_t>(i)));
            }
        }

        const auto subpassDescription = vk::SubpassDescription()
            .setPipelineBindPoint(vk::PipelineBindPoint::eGraphics)
            .setInputAttachmentCount(0)
            .setPInputAttachments(nullptr)
            .setColorAttachmentCount(static_cast<uint32_t>(attachmentReferences.size()))
            .setPColorAttachments(attachmentReferences.data())
            .setPResolveAttachments(nullptr)
            .setPDepthStencilAttachment(nullptr)
            .setPreserveAttachmentCount(0)
            .setPPreserveAttachments(nullptr);

        const auto renderPassCreateInfo = vk::RenderPassCreateInfo()
            .setAttachmentCount(static_cast<uint32_t>(attachmentDescriptions.size()))
            .setPAttachments(attachmentDescriptions.data())
            .setSubpassCount(1)
            .setPSubpasses(&subpassDescription)
            .setDependencyCount(0)
            .setPDependencies(nullptr);
        return device->createRenderPassUnique(renderPassCreateInfo);
    }

    static vk::Format convertVertexFormat(RenderState::VertexFormat vertexFormat) {
        switch (vertexFormat) {
        case RenderState::VertexFormat::Float:
            return vk::Format::eR32Sfloat;
        case RenderState::VertexFormat::Float2:
            return vk::Format::eR32G32Sfloat;
        case RenderState::VertexFormat::Float3:
            return vk::Format::eR32G32B32Sfloat;
        case RenderState::VertexFormat::Float4:
            return vk::Format::eR32G32B32A32Sfloat;
        default:
            assert(false);
            return vk::Format::eR32Sfloat;
        }
    }

    RenderState& DeviceImpl::getRenderState(const std::vector<uint8_t>& vertexShader, const std::string& vertexShaderName, const std::vector<uint8_t>& fragmentShader, const std::string& fragmentShaderName, const std::vector<unsigned int>& vertexAttributeBufferStrides, const std::vector<RenderState::VertexAttribute>& vertexAttributes, const std::vector<std::vector<ResourceType>>& resources, const std::vector<PixelFormat>* colorPixelFormats) {
        auto vertexShaderModule = prepareShader(vertexShader);
        auto fragmentShaderModule = prepareShader(fragmentShader);
        const vk::PipelineShaderStageCreateInfo shaderStages[2] = {
            vk::PipelineShaderStageCreateInfo().setStage(vk::ShaderStageFlagBits::eVertex).setModule(*vertexShaderModule).setPName(vertexShaderName.c_str()),
            vk::PipelineShaderStageCreateInfo().setStage(vk::ShaderStageFlagBits::eFragment).setModule(*fragmentShaderModule).setPName(fragmentShaderName.c_str()) };

        std::vector<vk::VertexInputBindingDescription> bindingDescriptions;
        for (std::size_t i = 0; i < vertexAttributeBufferStrides.size(); ++i) {
            unsigned int vertexAttributeBufferStride = vertexAttributeBufferStrides[i];
            bindingDescriptions.emplace_back(vk::VertexInputBindingDescription().setBinding(static_cast<uint32_t>(i)).setStride(vertexAttributeBufferStride).setInputRate(vk::VertexInputRate::eVertex));
        }

        std::vector<vk::VertexInputAttributeDescription> attributeDescriptions;
        for (std::size_t i = 0; i < vertexAttributes.size(); ++i) {
            const auto& vertexAttribute = vertexAttributes[i];
            attributeDescriptions.push_back(vk::VertexInputAttributeDescription().setLocation(static_cast<uint32_t>(i)).setBinding(vertexAttribute.vertexAttributeBufferIndex).setFormat(convertVertexFormat(vertexAttribute.format)).setOffset(vertexAttribute.offsetWithinStride));
        }

        const auto vertexInputInfo = vk::PipelineVertexInputStateCreateInfo()
            .setVertexBindingDescriptionCount(static_cast<uint32_t>(vertexAttributeBufferStrides.size()))
            .setPVertexBindingDescriptions(bindingDescriptions.data())
            .setVertexAttributeDescriptionCount(static_cast<uint32_t>(vertexAttributes.size()))
            .setPVertexAttributeDescriptions(attributeDescriptions.data());

        const auto inputAssemblyInfo = vk::PipelineInputAssemblyStateCreateInfo().setTopology(vk::PrimitiveTopology::eTriangleList);

        const auto viewportInfo = vk::PipelineViewportStateCreateInfo().setViewportCount(1).setScissorCount(1);

        const auto rasterizationInfo = vk::PipelineRasterizationStateCreateInfo()
            .setDepthClampEnable(VK_FALSE)
            .setRasterizerDiscardEnable(VK_FALSE)
            .setPolygonMode(vk::PolygonMode::eFill)
            .setCullMode(vk::CullModeFlagBits::eBack)
            .setFrontFace(vk::FrontFace::eClockwise)
            .setDepthBiasEnable(VK_FALSE)
            .setLineWidth(1.0f);

        const auto multisampleInfo = vk::PipelineMultisampleStateCreateInfo();

        const auto stencilOp = vk::StencilOpState()
            .setFailOp(vk::StencilOp::eKeep)
            .setPassOp(vk::StencilOp::eKeep)
            .setCompareOp(vk::CompareOp::eAlways);

        const auto depthStencilInfo = vk::PipelineDepthStencilStateCreateInfo()
            .setDepthTestEnable(VK_FALSE)
            .setDepthWriteEnable(VK_FALSE)
            .setDepthCompareOp(vk::CompareOp::eNever)
            .setDepthBoundsTestEnable(VK_FALSE)
            .setStencilTestEnable(VK_FALSE)
            .setFront(stencilOp)
            .setBack(stencilOp);

        const vk::PipelineColorBlendAttachmentState colorBlendAttachments[1] = {
            vk::PipelineColorBlendAttachmentState().setColorWriteMask(
                vk::ColorComponentFlagBits::eR | vk::ColorComponentFlagBits::eG | vk::ColorComponentFlagBits::eB |
                vk::ColorComponentFlagBits::eA) };

        const auto colorBlendInfo =
            vk::PipelineColorBlendStateCreateInfo().setAttachmentCount(1).setPAttachments(colorBlendAttachments);

        const vk::DynamicState dynamicStates[2] = { vk::DynamicState::eViewport, vk::DynamicState::eScissor };

        const auto dynamicStateInfo = vk::PipelineDynamicStateCreateInfo().setPDynamicStates(dynamicStates).setDynamicStateCount(2);

        auto pipelineLayout = createPipelineLayout(resources);
        auto compatibleRenderPass = createCompatibleRenderPass(colorPixelFormats);

        const auto graphicsPipelineCreateInfo = vk::GraphicsPipelineCreateInfo()
            .setStageCount(2)
            .setPStages(shaderStages)
            .setPVertexInputState(&vertexInputInfo)
            .setPInputAssemblyState(&inputAssemblyInfo)
            .setPViewportState(&viewportInfo)
            .setPRasterizationState(&rasterizationInfo)
            .setPMultisampleState(&multisampleInfo)
            .setPDepthStencilState(&depthStencilInfo)
            .setPColorBlendState(&colorBlendInfo)
            .setPDynamicState(&dynamicStateInfo)
            .setLayout(*pipelineLayout.first)
            .setRenderPass(*compatibleRenderPass);
        auto graphicsPipeline = device->createGraphicsPipelineUnique(*pipelineCache, graphicsPipelineCreateInfo);
        renderStates.emplace_back(RenderStateImpl(std::move(graphicsPipeline), std::move(pipelineLayout.second), std::move(pipelineLayout.first), std::move(compatibleRenderPass)));
        return renderStates.back();
    }

    ComputeState& DeviceImpl::getComputeState(const std::vector<uint8_t>& shader, const std::string& shaderName, const std::vector<std::vector<ResourceType>>& resources) {
        auto shaderModule = prepareShader(shader);
        const auto shaderStage = vk::PipelineShaderStageCreateInfo().setStage(vk::ShaderStageFlagBits::eCompute).setModule(*shaderModule).setPName(shaderName.c_str());

        auto pipelineLayout = createPipelineLayout(resources);

        const auto computePipelineCreateInfo = vk::ComputePipelineCreateInfo()
            .setStage(shaderStage)
            .setLayout(*pipelineLayout.first);
        auto computePipeline = device->createComputePipelineUnique(*pipelineCache, computePipelineCreateInfo);
        computeStates.emplace_back(ComputeStateImpl(std::move(computePipeline), std::move(pipelineLayout.second), std::move(pipelineLayout.first)));
        return computeStates.back();
    }

    BufferHolder DeviceImpl::getBuffer(unsigned int length) {
        auto result = bufferCache.emplace(length, ResourcePool<BufferImpl>());
        auto insertionTookPlace = result.second;
        auto& resourcePool = result.first->second;
        if (!resourcePool.freeList.empty()) {
            // FIXME: Zero-fill the texture somehow.
            auto buffer = std::move(resourcePool.freeList.back());
            resourcePool.freeList.pop_back();
            buffer.incrementReferenceCount();
            resourcePool.inUse.emplace_back(std::move(buffer));
            return BufferHolder(*this, resourcePool.inUse.back());
        }

        const auto bufferCreateInfo = vk::BufferCreateInfo().setSize(length).setUsage(vk::BufferUsageFlagBits::eTransferSrc | vk::BufferUsageFlagBits::eTransferDst | vk::BufferUsageFlagBits::eUniformBuffer | vk::BufferUsageFlagBits::eStorageBuffer | vk::BufferUsageFlagBits::eIndexBuffer | vk::BufferUsageFlagBits::eVertexBuffer | vk::BufferUsageFlagBits::eIndirectBuffer);
        auto buffer = device->createBufferUnique(bufferCreateInfo);
        auto memoryRequirements = device->getBufferMemoryRequirements(*buffer);
        auto memoryAllocateInfo = vk::MemoryAllocateInfo().setAllocationSize(memoryRequirements.size);
        bool found = false;
        for (int i = 0; i < VK_MAX_MEMORY_TYPES; ++i) {
            if ((memoryRequirements.memoryTypeBits & (1 << i)) && (memoryProperties.memoryTypes[i].propertyFlags & (vk::MemoryPropertyFlagBits::eHostVisible | vk::MemoryPropertyFlagBits::eHostCoherent))) {
                memoryAllocateInfo.setMemoryTypeIndex(i);
                found = true;
                break;
            }
        }
        assert(found);
        auto memory = device->allocateMemoryUnique(memoryAllocateInfo);
        device->bindBufferMemory(*buffer, *memory, 0);
        // FIXME: Zero-fill the texture somehow.
        std::function<void(BufferImpl&)> returnToDevice = [&](BufferImpl& buffer) {
            auto iterator = bufferCache.find(buffer.getLength());
            assert(iterator != bufferCache.end());
            auto& resourcePool = iterator->second;
            for (auto listIterator = resourcePool.inUse.begin(); listIterator != resourcePool.inUse.end(); ++listIterator) {
                if (&(*listIterator) == &buffer) {
                    auto buffer = std::move(*listIterator);
                    resourcePool.inUse.erase(listIterator);
                    resourcePool.freeList.emplace_back(std::move(buffer));
                    return;
                }
            }
            assert(false);
        };
        BufferImpl newBuffer(std::move(returnToDevice), length, *device, std::move(memory), std::move(buffer));
        newBuffer.incrementReferenceCount();
        resourcePool.inUse.emplace_back(std::move(newBuffer));
        return BufferHolder(*this, resourcePool.inUse.back());
    }

    void DeviceImpl::returnBuffer(Buffer& buffer) {
        auto* downcast = dynamic_cast<BufferImpl*>(&buffer);
        assert(downcast != nullptr);
        downcast->decrementReferenceCount();
    }

    TextureHolder DeviceImpl::getTexture(unsigned int width, unsigned int height, PixelFormat format) {
        TextureParameters textureParameters = { width, height, format };
        auto result = textureCache.emplace(std::move(textureParameters), ResourcePool<TextureImpl>());
        auto insertionTookPlace = result.second;
        auto& resourcePool = result.first->second;
        if (!resourcePool.freeList.empty()) {
            // FIXME: Zero-fill the texture somehow.
            auto buffer = std::move(resourcePool.freeList.back());
            resourcePool.freeList.pop_back();
            resourcePool.inUse.emplace_back(std::move(buffer));
            return TextureHolder(*this, resourcePool.inUse.back());
        }

        auto vulkanPixelFormat = convertPixelFormat(format);
        auto formatProperties = gpu.getFormatProperties(vulkanPixelFormat);
        assert(formatProperties.linearTilingFeatures & vk::FormatFeatureFlagBits::eSampledImage);

        // FIXME: Use staging textures so we can write into the texture linearly.
        const auto imageCreateInfo = vk::ImageCreateInfo()
            .setImageType(vk::ImageType::e2D)
            .setFormat(vulkanPixelFormat)
            .setExtent({ width, height, 1 })
            .setMipLevels(1)
            .setArrayLayers(1)
            .setSamples(vk::SampleCountFlagBits::e1)
            .setTiling(vk::ImageTiling::eOptimal)
            .setUsage(vk::ImageUsageFlagBits::eTransferSrc | vk::ImageUsageFlagBits::eTransferDst | vk::ImageUsageFlagBits::eSampled | vk::ImageUsageFlagBits::eColorAttachment)
            .setSharingMode(vk::SharingMode::eExclusive)
            .setQueueFamilyIndexCount(0)
            .setPQueueFamilyIndices(nullptr)
            .setInitialLayout(vk::ImageLayout::ePreinitialized);
        auto image = device->createImageUnique(imageCreateInfo);
        auto memoryRequirements = device->getImageMemoryRequirements(*image);
        auto memoryAllocateInfo = vk::MemoryAllocateInfo().setAllocationSize(memoryRequirements.size);
        bool found = false;
        for (int i = 0; i < VK_MAX_MEMORY_TYPES; ++i) {
            if ((memoryRequirements.memoryTypeBits & (1 << i))) {
                memoryAllocateInfo.setMemoryTypeIndex(i);
                found = true;
                break;
            }
        }
        assert(found);
        auto memory = device->allocateMemoryUnique(memoryAllocateInfo);
        device->bindImageMemory(*image, *memory, 0);
        // FIXME: Zero-fill the texture somehow.
        const auto imageViewCreateInfo = vk::ImageViewCreateInfo()
            .setImage(*image)
            .setViewType(vk::ImageViewType::e2D)
            .setFormat(vulkanPixelFormat)
            .setSubresourceRange(vk::ImageSubresourceRange(vk::ImageAspectFlagBits::eColor, 0, 1, 0, 1));;
        auto imageView = device->createImageViewUnique(imageViewCreateInfo);
        std::function<void(TextureImpl&)> returnToDevice = [&](TextureImpl& texture) {
            TextureParameters textureParameters = { texture.getWidth(), texture.getHeight(), convertFormat(texture.getFormat()) };
            auto iterator = textureCache.find(textureParameters);
            assert(iterator != textureCache.end());
            auto& resourcePool = iterator->second;
            for (auto listIterator = resourcePool.inUse.begin(); listIterator != resourcePool.inUse.end(); ++listIterator) {
                if (&(*listIterator) == &texture) {
                    auto buffer = std::move(*listIterator);
                    resourcePool.inUse.erase(listIterator);
                    resourcePool.freeList.emplace_back(std::move(buffer));
                    return;
                }
            }
            assert(false);
        };
        TextureImpl newTexture(std::move(returnToDevice), width, height, vulkanPixelFormat, *device, std::move(memory), std::move(image), std::move(imageView));
        newTexture.incrementReferenceCount();
        resourcePool.inUse.emplace_back(std::move(newTexture));
        return TextureHolder(*this, resourcePool.inUse.back());
    }

    void DeviceImpl::returnTexture(Texture& texture) {
        auto* downcast = dynamic_cast<TextureImpl*>(&texture);
        assert(downcast != nullptr);
        downcast->decrementReferenceCount();
    }

    SamplerHolder DeviceImpl::getSampler(AddressMode addressMode, Filter filter) {
        auto result = samplerCache.emplace((static_cast<uint32_t>(addressMode) << 8) | static_cast<uint32_t>(filter), ResourcePool<SamplerImpl>());
        auto insertionTookPlace = result.second;
        auto& resourcePool = result.first->second;
        if (!resourcePool.freeList.empty()) {
            auto sampler = std::move(resourcePool.freeList.back());
            resourcePool.freeList.pop_back();
            sampler.incrementReferenceCount();
            resourcePool.inUse.emplace_back(std::move(sampler));
            return SamplerHolder(*this, resourcePool.inUse.back());
        }

        vk::Filter vulkanFilter;
        vk::SamplerMipmapMode mipmapMode;
        switch (filter) {
        case Filter::Nearest:
            vulkanFilter = vk::Filter::eNearest;
            mipmapMode = vk::SamplerMipmapMode::eNearest;
            break;
        case Filter::Linear:
            vulkanFilter = vk::Filter::eLinear;
            mipmapMode = vk::SamplerMipmapMode::eLinear;
            break;
        default:
            assert(false);
        }

        vk::SamplerAddressMode vulkanAddressMode;
        switch (addressMode) {
        case AddressMode::ClampToEdge:
            vulkanAddressMode = vk::SamplerAddressMode::eClampToEdge;
            break;
        case AddressMode::MirrorClampToEdge:
            vulkanAddressMode = vk::SamplerAddressMode::eMirrorClampToEdge;
            break;
        case AddressMode::Repeat:
            vulkanAddressMode = vk::SamplerAddressMode::eRepeat;
            break;
        case AddressMode::MirrorRepeat:
            vulkanAddressMode = vk::SamplerAddressMode::eMirroredRepeat;
            break;
        }

        const auto samplerCreateInfo = vk::SamplerCreateInfo()
            .setMagFilter(vulkanFilter)
            .setMinFilter(vulkanFilter)
            .setMipmapMode(mipmapMode)
            .setAddressModeU(vulkanAddressMode)
            .setAddressModeV(vulkanAddressMode)
            .setAddressModeW(vulkanAddressMode);
        auto sampler = device->createSamplerUnique(samplerCreateInfo);

        std::function<void(SamplerImpl&)> returnToDevice = [&](SamplerImpl& sampler) {
            AddressMode addressMode;
            switch (sampler.getAddressMode()) {
            case vk::SamplerAddressMode::eClampToEdge:
                addressMode = AddressMode::ClampToEdge;
                break;
            case vk::SamplerAddressMode::eMirrorClampToEdge:
                addressMode = AddressMode::MirrorClampToEdge;
                break;
            case vk::SamplerAddressMode::eRepeat:
                addressMode = AddressMode::Repeat;
                break;
            case vk::SamplerAddressMode::eMirroredRepeat:
                addressMode = AddressMode::MirrorRepeat;
                break;
            default:
                assert(false);
            }
            Filter filter;
            switch (sampler.getFilter()) {
            case vk::Filter::eNearest:
                filter = Filter::Nearest;
                break;
            case vk::Filter::eLinear:
                filter = Filter::Linear;
                break;
            default:
                assert(false);
            }

            auto iterator = samplerCache.find((static_cast<uint32_t>(addressMode) << 8) | static_cast<uint32_t>(filter));
            assert(iterator != samplerCache.end());
            auto& resourcePool = iterator->second;
            for (auto listIterator = resourcePool.inUse.begin(); listIterator != resourcePool.inUse.end(); ++listIterator) {
                if (&(*listIterator) == &sampler) {
                    auto sampler = std::move(*listIterator);
                    resourcePool.inUse.erase(listIterator);
                    resourcePool.freeList.emplace_back(std::move(sampler));
                    return;
                }
            }
            assert(false);
        };
        SamplerImpl newSampler(std::move(returnToDevice), vulkanFilter, mipmapMode, vulkanAddressMode, *device, std::move(sampler));
        newSampler.incrementReferenceCount();
        resourcePool.inUse.emplace_back(std::move(newSampler));
        return SamplerHolder(*this, resourcePool.inUse.back());
    }

    void DeviceImpl::returnSampler(Sampler& sampler) {
        auto* downcast = dynamic_cast<SamplerImpl*>(&sampler);
        assert(downcast != nullptr);
        downcast->decrementReferenceCount();
    }

    DeviceImpl::~DeviceImpl() {
        for (std::size_t i = 0; i < swapchainImages.size(); ++i)
            static_cast<Queue*>(queue.get())->present();
    }
}