やっていくVulkan入門

5-11. デスクリプタ(作成・バインド)

この節では前節で準備したデータをシェーダに渡す処理を書いていきます。

「デスクリプタセット」「デスクリプタプール」「デスクリプタセットレイアウト」 という3種類のオブジェクトが出てきて面倒ですが、まとめて覚えてしまいましょう。

デスクリプタに関連する3つのオブジェクト

1つのデスクリプタはおおよそ1つのユニフォーム変数に対応します。前節のシェーダに書かれたsceneDataが例えばそうです。

デスクリプタは複数組み合わさってデスクリプタセットという単位を形成します。デスクリプタを扱う際は基本的にこのデスクリプタセットを単位として扱います。デスクリプタセットの中にはデスクリプタが順番に並んでいます。

デスクリプタセットを構築する際にはデスクリプタセットレイアウトが必要になります。これは「デスクリプタセットの何番目のデスクリプタはこのタイプで、数はいくつ」といった情報です。

例えるならデスクリプタセットは構造体型変数、デスクリプタは構造体の1個1個のメンバ変数、デスクリプタセットレイアウトは構造体定義のようなものです。

デスクリプタセットを構築する際にはデスクリプタプールというものも必要になります。これはデスクリプタのデータ容量の実体です。バッファに対するデバイスメモリ、コマンドバッファに対するコマンドプールのようなものと考えると良いでしょう。

バッファの作成

例によってGPUにデータを渡すのでデータをバッファに詰めます。usageはvk::BufferUsageFlagBits::eUniformBufferを指定します。

vk::BufferCreateInfo uniformBufferCreateInfo;
uniformBufferCreateInfo.size = sizeof(SceneData);
uniformBufferCreateInfo.usage = vk::BufferUsageFlagBits::eUniformBuffer;
uniformBufferCreateInfo.sharingMode = vk::SharingMode::eExclusive;

vk::UniqueBuffer uniformBuf = device->createBufferUnique(uniformBufferCreateInfo);

vk::MemoryRequirements uniformBufMemReq = device->getBufferMemoryRequirements(uniformBuf.get());
    
vk::MemoryAllocateInfo uniformBufMemAllocInfo;
uniformBufMemAllocInfo.allocationSize = uniformBufMemReq.size;

suitableMemoryTypeFound = false;
for (uint32_t i = 0; i < memProps.memoryTypeCount; i++) {
    if (uniformBufMemReq.memoryTypeBits & (1 << i) &&
        (memProps.memoryTypes[i].propertyFlags & vk::MemoryPropertyFlagBits::eHostVisible)) {
        uniformBufMemAllocInfo.memoryTypeIndex = i;
        suitableMemoryTypeFound = true;
        break;
    }
}
if (!suitableMemoryTypeFound) {
    std::cerr << "適切なメモリタイプが存在しません。" << std::endl;
    return -1;
}

vk::UniqueDeviceMemory uniformBufMemory = device->allocateMemoryUnique(uniformBufMemAllocInfo);

device->bindBufferMemory(uniformBuf.get(), uniformBufMemory.get(), 0);

{
    void* pUniformBufMem = device->mapMemory(uniformBufMemory.get(), 0, sizeof(SceneData));

    std::memcpy(pUniformBufMem, &sceneData, sizeof(SceneData));

    vk::MappedMemoryRange flushMemoryRange;
    flushMemoryRange.memory = uniformBufMemory.get();
    flushMemoryRange.offset = 0;
    flushMemoryRange.size = sizeof(SceneData);

    device->flushMappedMemoryRanges({ flushMemoryRange });

    device->unmapMemory(uniformBufMemory.get());
}

デバイスローカルにしないの？みたいな話はちょっと別でやります。

デスクリプタセットレイアウトの作成

まず最初にデスクリプタセットレイアウトを作成します。

今回はバッファを1つだけ渡すので、バッファを1つだけ持っているデスクリプタセットの構造を指定します。

vk::DescriptorSetLayoutBinding descSetLayoutBinding[1];
descSetLayoutBinding[0].binding = 0;
descSetLayoutBinding[0].descriptorType = vk::DescriptorType::eUniformBuffer;
descSetLayoutBinding[0].descriptorCount = 1;
descSetLayoutBinding[0].stageFlags = vk::ShaderStageFlagBits::eVertex;

vk::DescriptorSetLayoutCreateInfo descSetLayoutCreateInfo{};
descSetLayoutCreateInfo.bindingCount = 1;
descSetLayoutCreateInfo.pBindings = descSetLayoutBinding;

vk::UniqueDescriptorSetLayout descSetLayout = device->createDescriptorSetLayoutUnique(descSetLayoutCreateInfo);

vk::DescriptorSetLayoutBindingがデスクリプタ1つの情報を表します。 これの配列からデスクリプタセットレイアウトを作成します。

各メンバの意味は以下の通りです。

binding はシェーダと結びつけるための番号を表します。バインディング番号と呼びます。 頂点シェーダにlayout(set = 0, binding = 0)などと指定しましたが、このときのbindingの数字と揃えてあることに注意しましょう。

descriptorType はデスクリプタの種別を示します。今回シェーダに渡すものはバッファなのでvk::DescriptorType::eUniformBufferを指定します。

descriptorCount はデスクリプタの個数を表します。デスクリプタは配列として複数のデータを持てるのですが、ここにその要素数を指定します。今回は1個だけなので1を指定します。

stageFlags はデータを渡す対象となるシェーダを示します。今回は頂点シェーダだけに渡すのでvk::ShaderStageFlagBits::eVertexを指定しています。フラグメントシェーダに渡したい場合はvk::ShaderStageFlagBits::eFragmentを指定します。ビットマスクなので、ORで重ねれば両方に渡すことも可能です。

パイプラインレイアウトへの設定

デスクリプタセットレイアウトを作成したあとはそれをパイプラインレイアウトに設定する必要があります。

auto pipelineDescSetLayouts = { descSetLayout.get() };

vk::PipelineLayoutCreateInfo layoutCreateInfo;
layoutCreateInfo.setLayoutCount = pipelineDescSetLayouts.size();
layoutCreateInfo.pSetLayouts = pipelineDescSetLayouts.begin();

vk::UniquePipelineLayout pipelineLayout = device->createPipelineLayoutUnique(layoutCreateInfo);

パイプラインは描画の手順を表すオブジェクトです。頂点入力デスクリプションなどと同様、シェーダへのデータの読み込ませ方はここで設定するというわけですね。

デスクリプタプールの作成

次にデスクリプタプールを作成します。

重要なこととしてデスクリプタには種類があります。そのためデスクリプタプールも、「この種類のデスクリプタをこの数」と指定して作成する必要があります。必要な種類と数をきちんと指定しましょう。

vk::DescriptorPoolSize descPoolSize[1];
descPoolSize[0].type = vk::DescriptorType::eUniformBuffer;
descPoolSize[0].descriptorCount = 1;

vk::DescriptorPoolCreateInfo descPoolCreateInfo;
descPoolCreateInfo.poolSizeCount = std::size(descPoolSize);
descPoolCreateInfo.pPoolSizes = descPoolSize;
descPoolCreateInfo.maxSets = 1;

vk::UniqueDescriptorPool descPool = device->createDescriptorPoolUnique(descPoolCreateInfo);

vk::DescriptorPoolSizeの配列を poolSizeCountとpPoolSizes に指定します。

大体見れば分かる感じですが、vk::DescriptorPoolSizeはtypeがデスクリプタの種類でdescriptorCountがデスクリプタの数です。

vk::DescriptorPoolCreateInfoに maxSets というメンバがありますが、これはデスクリプタプールから作成するデスクリプタセットの数の上限を指定します。ここでは1を指定しています。

デスクリプタセットの作成

最後にデスクリプタセットを作成します。デスクリプタセットはデバイスの allocateDescriptorSetsメソッドを用いて作成します。 createではなくallocateなあたりで「デスクリプタプールから割り当てる」という気持ちが読み取れますね。

vk::DescriptorSetAllocateInfo descSetAllocInfo;

auto descSetLayouts = { descSetLayout.get() };

descSetAllocInfo.descriptorPool = descPool.get();
descSetAllocInfo.descriptorSetCount = descSetLayouts.size();
descSetAllocInfo.pSetLayouts = descSetLayouts.begin();

std::vector<vk::UniqueDescriptorSet> descSets = device->allocateDescriptorSetsUnique(descSetAllocInfo);

構造を示すデスクリプタセットレイアウト、実体を記録するデスクリプタプールを指定して作成します。

またSetsと複数形になっているところから分かる通り、一度に複数のデスクリプタセットを作成できます。デスクリプタセットレイアウトが配列によって複数渡せるようになっているのはそのためです。

デスクリプタ関係でややこしいのは、デスクリプタセットを表すvk::DescriptorSet、デスクリプタプールを表すvk::DescriptorPoolなどは存在するのに、1つのデスクリプタを表すvk::Descriptorなどというオブジェクトは存在しないということです。

デスクリプタは常に「あるデスクリプタセットの何番目のデスクリプタ」という形でしか触ることができません。 混乱しないよう気を付けましょう。

デスクリプタの内容更新

今はまだデスクリプタセットを作っただけでその中身は何もないので、updateDescriptorSetsで中身を設定する必要があります。

デスクリプタへの書き込み情報はvk::WriteDescriptorSet構造体で表されます。

vk::WriteDescriptorSet writeDescSet;
writeDescSet.dstSet = descSets[0].get();
writeDescSet.dstBinding = 0;
writeDescSet.dstArrayElement = 0;
writeDescSet.descriptorType = vk::DescriptorType::eUniformBuffer;

vk::DescriptorBufferInfo descBufInfo[1];
descBufInfo[0].buffer = uniformBuf.get();
descBufInfo[0].offset = 0;
descBufInfo[0].range = sizeof(SceneData);

writeDescSet.descriptorCount = 1;
writeDescSet.pBufferInfo = descBufInfo;

device->updateDescriptorSets({ writeDescSet }, {});

一度に複数のvk::WriteDescriptorSetをupdateDescriptorSetsに渡せば複数のデスクリプタの更新を行うことも可能です。

dstSet は書き込みの対象とするデスクリプタセットです。

dstBinding は書き込みの対象とするデスクリプタのバインディング番号です。

dstArrayElement は書き込みの対象とするデスクリプタの配列要素の番号です。 デスクリプタは配列であって複数のデータが持てる、という話をしたかと思いますが、その配列上の何番からの要素に書き込むかをここに指定します。 今回は0を指定します。

descriptorType は書き込みの対象となるデスクリプタの種別です。 ここではvk::DescriptorType::eUniformBufferを指定します。

バッファタイプのデスクリプタに書き込む場合、vk::DescriptorBufferInfo の配列を pBufferInfoとdescriptorCount に指定します。

vk::DescriptorBufferInfoのメンバについて解説すると、buffer が用いるバッファ、offset がバッファ上の先頭から何バイト目からをデータとして用いるか、range がデータの大きさ(バイト数)になります。

混乱を避けるために書いておくと、デスクリプタが持っている情報は「0.3, -0.2」といった数値ではなく、あくまで「このバッファのこの位置のデータをシェーダに渡す」という情報です。デスクリプタ=ポインタみたいなものと考えた方が良いかと思います。

従って、データの変更のたびにupdateDescriptorSetsを呼ばなくてもバッファのメモリ内容を書き換えればシェーダに渡すデータも変えられます。途中で別のバッファや別の領域を使うといったことをしない限り、updateDescriptorSetsによる設定は最初の1回だけで十分です。

デスクリプタセットのバインド

ここまで来たらあとはバインドするだけです。これはコマンドバッファのbindDescriptorSetsで行うことが出来ます。

描画処理に一行足しましょう。

cmdBufs[0]->bindPipeline(vk::PipelineBindPoint::eGraphics, pipeline.get());
cmdBufs[0]->bindVertexBuffers(0, { vertexBuf.get() }, { 0 });
cmdBufs[0]->bindIndexBuffer(indexBuf.get(), 0, vk::IndexType::eUint16);

// 追加
cmdBufs[0]->bindDescriptorSets(vk::PipelineBindPoint::eGraphics, pipelineLayout.get(), 0, { descSets[0].get() }, {});

cmdBufs[0]->drawIndexed(indices.size(), 1, 0, 0, 0);

第一引数は結びつける対象となるパイプラインの種類です。今は普通のグラフィックスパイプラインなのでvk::PipelineBindPoint::eGraphicsを指定します。

第二引数はパイプラインレイアウトです。

第三引数、第四引数で結びつけるデスクリプタセット、および結びつける場所を指定します。

実は、一度に複数のデスクリプタセットをバインドすることも可能です。バインドしたデスクリプタセットにはそれぞれセット番号が0,1,2,...と振られます。頂点シェーダでset = 0などと指定していたのはこの意味です。

仮に第三引数に3、第四引数に4つのデスクリプタセットを指定した場合は、セット番号3,4,5,6にそれぞれバインドされるでしょう。今回はセット番号0番にデスクリプタセット1つを結びつけるだけなのでこのように書いています。

第五引数は今は特に使いません。

これでユニフォーム変数をシェーダに渡す処理は完成です。頂点シェーダを前節で出したものに変えて下さい。

#version 450
#extension GL_ARB_separate_shader_objects : enable

layout(set = 0, binding = 0) uniform SceneData {
    vec2 rectCenter;
} sceneData;

layout(location = 0) in vec2 inPos;
layout(location = 1) in vec3 inColor;
layout(location = 0) out vec3 fragmentColor;

void main() {
    gl_Position = vec4(sceneData.rectCenter + inPos, 0.0, 1.0);
    fragmentColor = inColor;
}

それで実行してみましょう。以下のような画像が出ましたでしょうか。

渡した値の通り、右上に少し移動しています。ちゃんとrectCenterの値が渡っていることが分かりますね。値を変えて、実際に反映されるか確認してみましょう。

この節ではデスクリプタの使い方を解説しました。ちょっと分量が多かったでしょうか。次章のテクスチャの理解においても必須の知識なので、コードを辿ってしっかり理解してください。

この節のコード 
#include <vulkan/vulkan.hpp>
#include <GLFW/glfw3.h>
#include <filesystem>
#include <fstream>
#include <iostream>

const uint32_t screenWidth = 640;
const uint32_t screenHeight = 480;

struct Vec2 {
    float x, y;
};

struct Vec3 {
    float x, y, z;
};

struct Vertex {
    Vec2 pos;
    Vec3 color;
};

std::vector<Vertex> vertices = {
    Vertex{Vec2{-0.5f, -0.5f}, Vec3{0.0, 0.0, 1.0}},
    Vertex{Vec2{0.5f, 0.5f}, Vec3{0.0, 1.0, 0.0}},
    Vertex{Vec2{-0.5f, 0.5f}, Vec3{1.0, 0.0, 0.0}},
    Vertex{Vec2{0.5f, -0.5f}, Vec3{1.0, 1.0, 1.0}},
};

std::vector<uint16_t> indices = {0, 1, 2, 1, 0, 3};

struct SceneData {
    Vec2 rectCenter;
};

SceneData sceneData = { Vec2{ 0.3, -0.2 } };

int main() {
    if (!glfwInit())
        return -1;

    uint32_t requiredExtensionsCount;
    const char **requiredExtensions = glfwGetRequiredInstanceExtensions(&requiredExtensionsCount);

    vk::InstanceCreateInfo createInfo;
    createInfo.enabledExtensionCount = requiredExtensionsCount;
    createInfo.ppEnabledExtensionNames = requiredExtensions;

    vk::UniqueInstance instance;
    instance = vk::createInstanceUnique(createInfo);

    glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
    GLFWwindow *window;
    window = glfwCreateWindow(screenWidth, screenHeight, "GLFW Test Window", NULL, NULL);
    if (!window) {
        const char *err;
        glfwGetError(&err);
        std::cout << err << std::endl;
        glfwTerminate();
        return -1;
    }

    VkSurfaceKHR c_surface;
    auto result = glfwCreateWindowSurface(instance.get(), window, nullptr, &c_surface);
    if (result != VK_SUCCESS) {
        const char *err;
        glfwGetError(&err);
        std::cout << err << std::endl;
        glfwTerminate();
        return -1;
    }
    vk::UniqueSurfaceKHR surface{c_surface, instance.get()};

    std::vector<vk::PhysicalDevice> physicalDevices = instance->enumeratePhysicalDevices();

    vk::PhysicalDevice physicalDevice;
    bool existsSuitablePhysicalDevice = false;
    uint32_t graphicsQueueFamilyIndex;

    for (size_t i = 0; i < physicalDevices.size(); i++) {
        std::vector<vk::QueueFamilyProperties> queueProps = physicalDevices[i].getQueueFamilyProperties();
        bool existsGraphicsQueue = false;

        for (size_t j = 0; j < queueProps.size(); j++) {
            if (queueProps[j].queueFlags & vk::QueueFlagBits::eGraphics && physicalDevices[i].getSurfaceSupportKHR(j, surface.get())) {
                existsGraphicsQueue = true;
                graphicsQueueFamilyIndex = j;
                break;
            }
        }

        std::vector<vk::ExtensionProperties> extProps = physicalDevices[i].enumerateDeviceExtensionProperties();
        bool supportsSwapchainExtension = false;

        for (size_t j = 0; j < extProps.size(); j++) {
            if (std::string_view(extProps[j].extensionName.data()) == VK_KHR_SWAPCHAIN_EXTENSION_NAME) {
                supportsSwapchainExtension = true;
                break;
            }
        }

        if (existsGraphicsQueue && supportsSwapchainExtension) {
            physicalDevice = physicalDevices[i];
            existsSuitablePhysicalDevice = true;
            break;
        }
    }

    if (!existsSuitablePhysicalDevice) {
        std::cerr << "使用可能な物理デバイスがありません。" << std::endl;
        return -1;
    }

    vk::DeviceCreateInfo devCreateInfo;

    auto devRequiredExtensions = {VK_KHR_SWAPCHAIN_EXTENSION_NAME};

    devCreateInfo.enabledExtensionCount = devRequiredExtensions.size();
    devCreateInfo.ppEnabledExtensionNames = devRequiredExtensions.begin();

    vk::DeviceQueueCreateInfo queueCreateInfo[1];
    queueCreateInfo[0].queueFamilyIndex = graphicsQueueFamilyIndex;
    queueCreateInfo[0].queueCount = 1;

    float queuePriorities[1] = {1.0};

    queueCreateInfo[0].pQueuePriorities = queuePriorities;

    devCreateInfo.pQueueCreateInfos = queueCreateInfo;
    devCreateInfo.queueCreateInfoCount = 1;

    vk::UniqueDevice device = physicalDevice.createDeviceUnique(devCreateInfo);

    vk::Queue graphicsQueue = device->getQueue(graphicsQueueFamilyIndex, 0);

    vk::PhysicalDeviceMemoryProperties memProps = physicalDevice.getMemoryProperties();

    vk::BufferCreateInfo vertBufferCreateInfo;
    vertBufferCreateInfo.size = sizeof(Vertex) * vertices.size();
    vertBufferCreateInfo.usage = vk::BufferUsageFlagBits::eVertexBuffer | vk::BufferUsageFlagBits::eTransferDst;
    vertBufferCreateInfo.sharingMode = vk::SharingMode::eExclusive;

    vk::UniqueBuffer vertexBuf = device->createBufferUnique(vertBufferCreateInfo);

    vk::MemoryRequirements vertexBufMemReq = device->getBufferMemoryRequirements(vertexBuf.get());

    vk::MemoryAllocateInfo vertexBufMemAllocInfo;
    vertexBufMemAllocInfo.allocationSize = vertexBufMemReq.size;

    bool suitableMemoryTypeFound = false;
    for (uint32_t i = 0; i < memProps.memoryTypeCount; i++) {
        if (vertexBufMemReq.memoryTypeBits & (1 << i) && (memProps.memoryTypes[i].propertyFlags & vk::MemoryPropertyFlagBits::eDeviceLocal)) {
            vertexBufMemAllocInfo.memoryTypeIndex = i;
            suitableMemoryTypeFound = true;
            break;
        }
    }
    if (!suitableMemoryTypeFound) {
        std::cerr << "適切なメモリタイプが存在しません。" << std::endl;
        return -1;
    }

    vk::UniqueDeviceMemory vertexBufMemory = device->allocateMemoryUnique(vertexBufMemAllocInfo);

    device->bindBufferMemory(vertexBuf.get(), vertexBufMemory.get(), 0);

    {
        vk::BufferCreateInfo stagingBufferCreateInfo;
        stagingBufferCreateInfo.size = sizeof(Vertex) * vertices.size();
        stagingBufferCreateInfo.usage = vk::BufferUsageFlagBits::eTransferSrc;
        stagingBufferCreateInfo.sharingMode = vk::SharingMode::eExclusive;

        vk::UniqueBuffer stagingBuf = device->createBufferUnique(stagingBufferCreateInfo);

        vk::MemoryRequirements stagingBufMemReq = device->getBufferMemoryRequirements(stagingBuf.get());

        vk::MemoryAllocateInfo stagingBufMemAllocInfo;
        stagingBufMemAllocInfo.allocationSize = stagingBufMemReq.size;

        suitableMemoryTypeFound = false;
        for (uint32_t i = 0; i < memProps.memoryTypeCount; i++) {
            if (stagingBufMemReq.memoryTypeBits & (1 << i) && (memProps.memoryTypes[i].propertyFlags & vk::MemoryPropertyFlagBits::eHostVisible)) {
                stagingBufMemAllocInfo.memoryTypeIndex = i;
                suitableMemoryTypeFound = true;
                break;
            }
        }
        if (!suitableMemoryTypeFound) {
            std::cerr << "適切なメモリタイプが存在しません。" << std::endl;
            return -1;
        }

        vk::UniqueDeviceMemory stagingBufMemory = device->allocateMemoryUnique(stagingBufMemAllocInfo);

        device->bindBufferMemory(stagingBuf.get(), stagingBufMemory.get(), 0);

        void *pStagingBufMem = device->mapMemory(stagingBufMemory.get(), 0, sizeof(Vertex) * vertices.size());

        std::memcpy(pStagingBufMem, vertices.data(), sizeof(Vertex) * vertices.size());

        vk::MappedMemoryRange flushMemoryRange;
        flushMemoryRange.memory = stagingBufMemory.get();
        flushMemoryRange.offset = 0;
        flushMemoryRange.size = sizeof(Vertex) * vertices.size();

        device->flushMappedMemoryRanges({flushMemoryRange});

        device->unmapMemory(stagingBufMemory.get());

        vk::CommandPoolCreateInfo tmpCmdPoolCreateInfo;
        tmpCmdPoolCreateInfo.queueFamilyIndex = graphicsQueueFamilyIndex;
        tmpCmdPoolCreateInfo.flags = vk::CommandPoolCreateFlagBits::eTransient;
        vk::UniqueCommandPool tmpCmdPool = device->createCommandPoolUnique(tmpCmdPoolCreateInfo);

        vk::CommandBufferAllocateInfo tmpCmdBufAllocInfo;
        tmpCmdBufAllocInfo.commandPool = tmpCmdPool.get();
        tmpCmdBufAllocInfo.commandBufferCount = 1;
        tmpCmdBufAllocInfo.level = vk::CommandBufferLevel::ePrimary;
        std::vector<vk::UniqueCommandBuffer> tmpCmdBufs = device->allocateCommandBuffersUnique(tmpCmdBufAllocInfo);

        vk::BufferCopy bufCopy;
        bufCopy.srcOffset = 0;
        bufCopy.dstOffset = 0;
        bufCopy.size = sizeof(Vertex) * vertices.size();

        vk::CommandBufferBeginInfo cmdBeginInfo;
        cmdBeginInfo.flags = vk::CommandBufferUsageFlagBits::eOneTimeSubmit;

        tmpCmdBufs[0]->begin(cmdBeginInfo);
        tmpCmdBufs[0]->copyBuffer(stagingBuf.get(), vertexBuf.get(), {bufCopy});
        tmpCmdBufs[0]->end();

        vk::CommandBuffer submitCmdBuf[1] = {tmpCmdBufs[0].get()};
        vk::SubmitInfo submitInfo;
        submitInfo.commandBufferCount = 1;
        submitInfo.pCommandBuffers = submitCmdBuf;

        graphicsQueue.submit({submitInfo});
        graphicsQueue.waitIdle();
    }

    vk::BufferCreateInfo indexBufferCreateInfo;
    indexBufferCreateInfo.size = sizeof(uint16_t) * indices.size();
    indexBufferCreateInfo.usage = vk::BufferUsageFlagBits::eIndexBuffer | vk::BufferUsageFlagBits::eTransferDst;
    indexBufferCreateInfo.sharingMode = vk::SharingMode::eExclusive;

    vk::UniqueBuffer indexBuf = device->createBufferUnique(indexBufferCreateInfo);

    vk::MemoryRequirements indexBufMemReq = device->getBufferMemoryRequirements(indexBuf.get());

    vk::MemoryAllocateInfo indexBufMemAllocInfo;
    indexBufMemAllocInfo.allocationSize = indexBufMemReq.size;

    suitableMemoryTypeFound = false;
    for (uint32_t i = 0; i < memProps.memoryTypeCount; i++) {
        if (indexBufMemReq.memoryTypeBits & (1 << i) && (memProps.memoryTypes[i].propertyFlags & vk::MemoryPropertyFlagBits::eDeviceLocal)) {
            indexBufMemAllocInfo.memoryTypeIndex = i;
            suitableMemoryTypeFound = true;
            break;
        }
    }
    if (!suitableMemoryTypeFound) {
        std::cerr << "適切なメモリタイプが存在しません。" << std::endl;
        return -1;
    }

    vk::UniqueDeviceMemory indexBufMemory = device->allocateMemoryUnique(indexBufMemAllocInfo);

    device->bindBufferMemory(indexBuf.get(), indexBufMemory.get(), 0);

    {
        vk::BufferCreateInfo stagingBufferCreateInfo;
        stagingBufferCreateInfo.size = sizeof(uint16_t) * indices.size();
        stagingBufferCreateInfo.usage = vk::BufferUsageFlagBits::eTransferSrc;
        stagingBufferCreateInfo.sharingMode = vk::SharingMode::eExclusive;

        vk::UniqueBuffer stagingBuf = device->createBufferUnique(stagingBufferCreateInfo);

        vk::MemoryRequirements stagingBufMemReq = device->getBufferMemoryRequirements(stagingBuf.get());

        vk::MemoryAllocateInfo stagingBufMemAllocInfo;
        stagingBufMemAllocInfo.allocationSize = stagingBufMemReq.size;

        suitableMemoryTypeFound = false;
        for (uint32_t i = 0; i < memProps.memoryTypeCount; i++) {
            if (stagingBufMemReq.memoryTypeBits & (1 << i) && (memProps.memoryTypes[i].propertyFlags & vk::MemoryPropertyFlagBits::eHostVisible)) {
                stagingBufMemAllocInfo.memoryTypeIndex = i;
                suitableMemoryTypeFound = true;
                break;
            }
        }
        if (!suitableMemoryTypeFound) {
            std::cerr << "適切なメモリタイプが存在しません。" << std::endl;
            return -1;
        }

        vk::UniqueDeviceMemory stagingBufMemory = device->allocateMemoryUnique(stagingBufMemAllocInfo);

        device->bindBufferMemory(stagingBuf.get(), stagingBufMemory.get(), 0);

        void *pStagingBufMem = device->mapMemory(stagingBufMemory.get(), 0, sizeof(uint16_t) * indices.size());

        std::memcpy(pStagingBufMem, indices.data(), sizeof(uint16_t) * indices.size());

        vk::MappedMemoryRange flushMemoryRange;
        flushMemoryRange.memory = stagingBufMemory.get();
        flushMemoryRange.offset = 0;
        flushMemoryRange.size = sizeof(uint16_t) * indices.size();

        device->flushMappedMemoryRanges({flushMemoryRange});

        device->unmapMemory(stagingBufMemory.get());

        vk::CommandPoolCreateInfo tmpCmdPoolCreateInfo;
        tmpCmdPoolCreateInfo.queueFamilyIndex = graphicsQueueFamilyIndex;
        tmpCmdPoolCreateInfo.flags = vk::CommandPoolCreateFlagBits::eTransient;
        vk::UniqueCommandPool tmpCmdPool = device->createCommandPoolUnique(tmpCmdPoolCreateInfo);

        vk::CommandBufferAllocateInfo tmpCmdBufAllocInfo;
        tmpCmdBufAllocInfo.commandPool = tmpCmdPool.get();
        tmpCmdBufAllocInfo.commandBufferCount = 1;
        tmpCmdBufAllocInfo.level = vk::CommandBufferLevel::ePrimary;
        std::vector<vk::UniqueCommandBuffer> tmpCmdBufs = device->allocateCommandBuffersUnique(tmpCmdBufAllocInfo);

        vk::BufferCopy bufCopy;
        bufCopy.srcOffset = 0;
        bufCopy.dstOffset = 0;
        bufCopy.size = sizeof(uint16_t) * indices.size();

        vk::CommandBufferBeginInfo cmdBeginInfo;
        cmdBeginInfo.flags = vk::CommandBufferUsageFlagBits::eOneTimeSubmit;

        tmpCmdBufs[0]->begin(cmdBeginInfo);
        tmpCmdBufs[0]->copyBuffer(stagingBuf.get(), indexBuf.get(), {bufCopy});
        tmpCmdBufs[0]->end();

        vk::CommandBuffer submitCmdBuf[1] = {tmpCmdBufs[0].get()};
        vk::SubmitInfo submitInfo;
        submitInfo.commandBufferCount = 1;
        submitInfo.pCommandBuffers = submitCmdBuf;

        graphicsQueue.submit({submitInfo});
        graphicsQueue.waitIdle();
    }

    vk::BufferCreateInfo uniformBufferCreateInfo;
    uniformBufferCreateInfo.size = sizeof(SceneData);
    uniformBufferCreateInfo.usage = vk::BufferUsageFlagBits::eUniformBuffer;
    uniformBufferCreateInfo.sharingMode = vk::SharingMode::eExclusive;

    vk::UniqueBuffer uniformBuf = device->createBufferUnique(uniformBufferCreateInfo);

    vk::MemoryRequirements uniformBufMemReq = device->getBufferMemoryRequirements(uniformBuf.get());
        
    vk::MemoryAllocateInfo uniformBufMemAllocInfo;
    uniformBufMemAllocInfo.allocationSize = uniformBufMemReq.size;

    suitableMemoryTypeFound = false;
    for (uint32_t i = 0; i < memProps.memoryTypeCount; i++) {
        if (uniformBufMemReq.memoryTypeBits & (1 << i) &&
            (memProps.memoryTypes[i].propertyFlags & vk::MemoryPropertyFlagBits::eHostVisible)) {
            uniformBufMemAllocInfo.memoryTypeIndex = i;
            suitableMemoryTypeFound = true;
            break;
        }
    }
    if (!suitableMemoryTypeFound) {
        std::cerr << "適切なメモリタイプが存在しません。" << std::endl;
        return -1;
    }

    vk::UniqueDeviceMemory uniformBufMemory = device->allocateMemoryUnique(uniformBufMemAllocInfo);

    device->bindBufferMemory(uniformBuf.get(), uniformBufMemory.get(), 0);

    {
        void* pUniformBufMem = device->mapMemory(uniformBufMemory.get(), 0, sizeof(SceneData));

        std::memcpy(pUniformBufMem, &sceneData, sizeof(SceneData));

        vk::MappedMemoryRange flushMemoryRange;
        flushMemoryRange.memory = uniformBufMemory.get();
        flushMemoryRange.offset = 0;
        flushMemoryRange.size = sizeof(SceneData);

        device->flushMappedMemoryRanges({ flushMemoryRange });

        device->unmapMemory(uniformBufMemory.get());
    }

    vk::DescriptorSetLayoutBinding descSetLayoutBinding[1];
    descSetLayoutBinding[0].binding = 0;
    descSetLayoutBinding[0].descriptorType = vk::DescriptorType::eUniformBuffer;
    descSetLayoutBinding[0].descriptorCount = 1;
    descSetLayoutBinding[0].stageFlags = vk::ShaderStageFlagBits::eVertex;

    vk::DescriptorSetLayoutCreateInfo descSetLayoutCreateInfo{};
    descSetLayoutCreateInfo.bindingCount = 1;
    descSetLayoutCreateInfo.pBindings = descSetLayoutBinding;

    vk::UniqueDescriptorSetLayout descSetLayout = device->createDescriptorSetLayoutUnique(descSetLayoutCreateInfo);

    vk::DescriptorPoolSize descPoolSize[1];
    descPoolSize[0].type = vk::DescriptorType::eUniformBuffer;
    descPoolSize[0].descriptorCount = 1;

    vk::DescriptorPoolCreateInfo descPoolCreateInfo;
    descPoolCreateInfo.poolSizeCount = 1;
    descPoolCreateInfo.pPoolSizes = descPoolSize;
    descPoolCreateInfo.maxSets = 1;

    vk::UniqueDescriptorPool descPool = device->createDescriptorPoolUnique(descPoolCreateInfo);

    vk::DescriptorSetAllocateInfo descSetAllocInfo;

    auto descSetLayouts = { descSetLayout.get() };

    descSetAllocInfo.descriptorPool = descPool.get();
    descSetAllocInfo.descriptorSetCount = descSetLayouts.size();
    descSetAllocInfo.pSetLayouts = descSetLayouts.begin();

    std::vector<vk::UniqueDescriptorSet> descSets = device->allocateDescriptorSetsUnique(descSetAllocInfo);

    vk::WriteDescriptorSet writeDescSet;
    writeDescSet.dstSet = descSets[0].get();
    writeDescSet.dstBinding = 0;
    writeDescSet.dstArrayElement = 0;
    writeDescSet.descriptorType = vk::DescriptorType::eUniformBuffer;

    vk::DescriptorBufferInfo descBufInfo[1];
    descBufInfo[0].buffer = uniformBuf.get();
    descBufInfo[0].offset = 0;
    descBufInfo[0].range = sizeof(SceneData);

    writeDescSet.descriptorCount = 1;
    writeDescSet.pBufferInfo = descBufInfo;

    device->updateDescriptorSets({ writeDescSet }, {});

    std::vector<vk::SurfaceFormatKHR> surfaceFormats = physicalDevice.getSurfaceFormatsKHR(surface.get());
    std::vector<vk::PresentModeKHR> surfacePresentModes = physicalDevice.getSurfacePresentModesKHR(surface.get());

    vk::SurfaceFormatKHR swapchainFormat = surfaceFormats[0];
    vk::PresentModeKHR swapchainPresentMode = surfacePresentModes[0];

    vk::AttachmentDescription attachments[1];
    attachments[0].format = swapchainFormat.format;
    attachments[0].samples = vk::SampleCountFlagBits::e1;
    attachments[0].loadOp = vk::AttachmentLoadOp::eClear;
    attachments[0].storeOp = vk::AttachmentStoreOp::eStore;
    attachments[0].stencilLoadOp = vk::AttachmentLoadOp::eDontCare;
    attachments[0].stencilStoreOp = vk::AttachmentStoreOp::eDontCare;
    attachments[0].initialLayout = vk::ImageLayout::eUndefined;
    attachments[0].finalLayout = vk::ImageLayout::ePresentSrcKHR;

    vk::AttachmentReference subpass0_attachmentRefs[1];
    subpass0_attachmentRefs[0].attachment = 0;
    subpass0_attachmentRefs[0].layout = vk::ImageLayout::eColorAttachmentOptimal;

    vk::SubpassDescription subpasses[1];
    subpasses[0].pipelineBindPoint = vk::PipelineBindPoint::eGraphics;
    subpasses[0].colorAttachmentCount = 1;
    subpasses[0].pColorAttachments = subpass0_attachmentRefs;

    vk::RenderPassCreateInfo renderpassCreateInfo;
    renderpassCreateInfo.attachmentCount = 1;
    renderpassCreateInfo.pAttachments = attachments;
    renderpassCreateInfo.subpassCount = 1;
    renderpassCreateInfo.pSubpasses = subpasses;
    renderpassCreateInfo.dependencyCount = 0;
    renderpassCreateInfo.pDependencies = nullptr;

    vk::UniqueRenderPass renderpass = device->createRenderPassUnique(renderpassCreateInfo);

    vk::Viewport viewports[1];
    viewports[0].x = 0.0;
    viewports[0].y = 0.0;
    viewports[0].minDepth = 0.0;
    viewports[0].maxDepth = 1.0;
    viewports[0].width = screenWidth;
    viewports[0].height = screenHeight;

    vk::Rect2D scissors[1];
    scissors[0].offset = vk::Offset2D{0, 0};
    scissors[0].extent = vk::Extent2D{screenWidth, screenHeight};

    vk::PipelineViewportStateCreateInfo viewportState;
    viewportState.viewportCount = 1;
    viewportState.pViewports = viewports;
    viewportState.scissorCount = 1;
    viewportState.pScissors = scissors;

    vk::VertexInputBindingDescription vertexBindingDescription[1];
    vertexBindingDescription[0].binding = 0;
    vertexBindingDescription[0].stride = sizeof(Vertex);
    vertexBindingDescription[0].inputRate = vk::VertexInputRate::eVertex;

    vk::VertexInputAttributeDescription vertexInputDescription[2];
    vertexInputDescription[0].binding = 0;
    vertexInputDescription[0].location = 0;
    vertexInputDescription[0].format = vk::Format::eR32G32Sfloat;
    vertexInputDescription[0].offset = offsetof(Vertex, pos);
    vertexInputDescription[1].binding = 0;
    vertexInputDescription[1].location = 1;
    vertexInputDescription[1].format = vk::Format::eR32G32B32Sfloat;
    vertexInputDescription[1].offset = offsetof(Vertex, color);

    vk::PipelineVertexInputStateCreateInfo vertexInputInfo;
    vertexInputInfo.vertexBindingDescriptionCount = std::size(vertexBindingDescription);
    vertexInputInfo.pVertexBindingDescriptions = vertexBindingDescription;
    vertexInputInfo.vertexAttributeDescriptionCount = std::size(vertexInputDescription);
    vertexInputInfo.pVertexAttributeDescriptions = vertexInputDescription;

    vk::PipelineInputAssemblyStateCreateInfo inputAssembly;
    inputAssembly.topology = vk::PrimitiveTopology::eTriangleList;
    inputAssembly.primitiveRestartEnable = false;

    vk::PipelineRasterizationStateCreateInfo rasterizer;
    rasterizer.depthClampEnable = false;
    rasterizer.rasterizerDiscardEnable = false;
    rasterizer.polygonMode = vk::PolygonMode::eFill;
    rasterizer.lineWidth = 1.0f;
    rasterizer.cullMode = vk::CullModeFlagBits::eBack;
    rasterizer.frontFace = vk::FrontFace::eClockwise;
    rasterizer.depthBiasEnable = false;

    vk::PipelineMultisampleStateCreateInfo multisample;
    multisample.sampleShadingEnable = false;
    multisample.rasterizationSamples = vk::SampleCountFlagBits::e1;

    vk::PipelineColorBlendAttachmentState blendattachment[1];
    blendattachment[0].colorWriteMask = vk::ColorComponentFlagBits::eA | vk::ColorComponentFlagBits::eR | vk::ColorComponentFlagBits::eG | vk::ColorComponentFlagBits::eB;
    blendattachment[0].blendEnable = false;

    vk::PipelineColorBlendStateCreateInfo blend;
    blend.logicOpEnable = false;
    blend.attachmentCount = 1;
    blend.pAttachments = blendattachment;

    auto pipelineDescSetLayouts = { descSetLayout.get() };

    vk::PipelineLayoutCreateInfo layoutCreateInfo;
    layoutCreateInfo.setLayoutCount = pipelineDescSetLayouts.size();
    layoutCreateInfo.pSetLayouts = pipelineDescSetLayouts.begin();

    vk::UniquePipelineLayout pipelineLayout = device->createPipelineLayoutUnique(layoutCreateInfo);

    size_t vertSpvFileSz = std::filesystem::file_size("shader.vert.spv");

    std::ifstream vertSpvFile("shader.vert.spv", std::ios_base::binary);

    std::vector<char> vertSpvFileData(vertSpvFileSz);
    vertSpvFile.read(vertSpvFileData.data(), vertSpvFileSz);

    vk::ShaderModuleCreateInfo vertShaderCreateInfo;
    vertShaderCreateInfo.codeSize = vertSpvFileSz;
    vertShaderCreateInfo.pCode = reinterpret_cast<const uint32_t *>(vertSpvFileData.data());

    vk::UniqueShaderModule vertShader = device->createShaderModuleUnique(vertShaderCreateInfo);

    size_t fragSpvFileSz = std::filesystem::file_size("shader.frag.spv");

    std::ifstream fragSpvFile("shader.frag.spv", std::ios_base::binary);

    std::vector<char> fragSpvFileData(fragSpvFileSz);
    fragSpvFile.read(fragSpvFileData.data(), fragSpvFileSz);

    vk::ShaderModuleCreateInfo fragShaderCreateInfo;
    fragShaderCreateInfo.codeSize = fragSpvFileSz;
    fragShaderCreateInfo.pCode = reinterpret_cast<const uint32_t *>(fragSpvFileData.data());

    vk::UniqueShaderModule fragShader = device->createShaderModuleUnique(fragShaderCreateInfo);

    vk::PipelineShaderStageCreateInfo shaderStage[2];
    shaderStage[0].stage = vk::ShaderStageFlagBits::eVertex;
    shaderStage[0].module = vertShader.get();
    shaderStage[0].pName = "main";
    shaderStage[1].stage = vk::ShaderStageFlagBits::eFragment;
    shaderStage[1].module = fragShader.get();
    shaderStage[1].pName = "main";

    vk::GraphicsPipelineCreateInfo pipelineCreateInfo;
    pipelineCreateInfo.pViewportState = &viewportState;
    pipelineCreateInfo.pVertexInputState = &vertexInputInfo;
    pipelineCreateInfo.pInputAssemblyState = &inputAssembly;
    pipelineCreateInfo.pRasterizationState = &rasterizer;
    pipelineCreateInfo.pMultisampleState = &multisample;
    pipelineCreateInfo.pColorBlendState = &blend;
    pipelineCreateInfo.layout = pipelineLayout.get();
    pipelineCreateInfo.renderPass = renderpass.get();
    pipelineCreateInfo.subpass = 0;
    pipelineCreateInfo.stageCount = 2;
    pipelineCreateInfo.pStages = shaderStage;

    vk::UniquePipeline pipeline = device->createGraphicsPipelineUnique(nullptr, pipelineCreateInfo).value;

    vk::UniqueSwapchainKHR swapchain;
    std::vector<vk::Image> swapchainImages;
    std::vector<vk::UniqueImageView> swapchainImageViews;
    std::vector<vk::UniqueFramebuffer> swapchainFramebufs;

    auto recreateSwapchain = [&]() {
        swapchainFramebufs.clear();
        swapchainImageViews.clear();
        swapchainImages.clear();
        swapchain.reset();

        vk::SurfaceCapabilitiesKHR surfaceCapabilities = physicalDevice.getSurfaceCapabilitiesKHR(surface.get());

        vk::SwapchainCreateInfoKHR swapchainCreateInfo;
        swapchainCreateInfo.surface = surface.get();
        swapchainCreateInfo.minImageCount = surfaceCapabilities.minImageCount + 1;
        swapchainCreateInfo.imageFormat = swapchainFormat.format;
        swapchainCreateInfo.imageColorSpace = swapchainFormat.colorSpace;
        swapchainCreateInfo.imageExtent = surfaceCapabilities.currentExtent;
        swapchainCreateInfo.imageArrayLayers = 1;
        swapchainCreateInfo.imageUsage = vk::ImageUsageFlagBits::eColorAttachment;
        swapchainCreateInfo.imageSharingMode = vk::SharingMode::eExclusive;
        swapchainCreateInfo.preTransform = surfaceCapabilities.currentTransform;
        swapchainCreateInfo.presentMode = swapchainPresentMode;
        swapchainCreateInfo.clipped = VK_TRUE;

        swapchain = device->createSwapchainKHRUnique(swapchainCreateInfo);

        swapchainImages = device->getSwapchainImagesKHR(swapchain.get());

        swapchainImageViews.resize(swapchainImages.size());

        for (size_t i = 0; i < swapchainImages.size(); i++) {
            vk::ImageViewCreateInfo imgViewCreateInfo;
            imgViewCreateInfo.image = swapchainImages[i];
            imgViewCreateInfo.viewType = vk::ImageViewType::e2D;
            imgViewCreateInfo.format = swapchainFormat.format;
            imgViewCreateInfo.components.r = vk::ComponentSwizzle::eIdentity;
            imgViewCreateInfo.components.g = vk::ComponentSwizzle::eIdentity;
            imgViewCreateInfo.components.b = vk::ComponentSwizzle::eIdentity;
            imgViewCreateInfo.components.a = vk::ComponentSwizzle::eIdentity;
            imgViewCreateInfo.subresourceRange.aspectMask = vk::ImageAspectFlagBits::eColor;
            imgViewCreateInfo.subresourceRange.baseMipLevel = 0;
            imgViewCreateInfo.subresourceRange.levelCount = 1;
            imgViewCreateInfo.subresourceRange.baseArrayLayer = 0;
            imgViewCreateInfo.subresourceRange.layerCount = 1;

            swapchainImageViews[i] = device->createImageViewUnique(imgViewCreateInfo);
        }

        swapchainFramebufs.resize(swapchainImages.size());

        for (size_t i = 0; i < swapchainImages.size(); i++) {
            vk::ImageView frameBufAttachments[1];
            frameBufAttachments[0] = swapchainImageViews[i].get();

            vk::FramebufferCreateInfo frameBufCreateInfo;
            frameBufCreateInfo.width = surfaceCapabilities.currentExtent.width;
            frameBufCreateInfo.height = surfaceCapabilities.currentExtent.height;
            frameBufCreateInfo.layers = 1;
            frameBufCreateInfo.renderPass = renderpass.get();
            frameBufCreateInfo.attachmentCount = 1;
            frameBufCreateInfo.pAttachments = frameBufAttachments;

            swapchainFramebufs[i] = device->createFramebufferUnique(frameBufCreateInfo);
        }
    };

    recreateSwapchain();

    vk::CommandPoolCreateInfo cmdPoolCreateInfo;
    cmdPoolCreateInfo.queueFamilyIndex = graphicsQueueFamilyIndex;
    cmdPoolCreateInfo.flags = vk::CommandPoolCreateFlagBits::eResetCommandBuffer;
    vk::UniqueCommandPool cmdPool = device->createCommandPoolUnique(cmdPoolCreateInfo);

    vk::CommandBufferAllocateInfo cmdBufAllocInfo;
    cmdBufAllocInfo.commandPool = cmdPool.get();
    cmdBufAllocInfo.commandBufferCount = 1;
    cmdBufAllocInfo.level = vk::CommandBufferLevel::ePrimary;
    std::vector<vk::UniqueCommandBuffer> cmdBufs = device->allocateCommandBuffersUnique(cmdBufAllocInfo);

    vk::SemaphoreCreateInfo semaphoreCreateInfo;

    vk::UniqueSemaphore swapchainImgSemaphore, imgRenderedSemaphore;
    swapchainImgSemaphore = device->createSemaphoreUnique(semaphoreCreateInfo);
    imgRenderedSemaphore = device->createSemaphoreUnique(semaphoreCreateInfo);

    vk::FenceCreateInfo fenceCreateInfo;
    fenceCreateInfo.flags = vk::FenceCreateFlagBits::eSignaled;

    vk::UniqueFence imgRenderedFence = device->createFenceUnique(fenceCreateInfo);

    while (!glfwWindowShouldClose(window)) {
        glfwPollEvents();

        device->waitForFences({imgRenderedFence.get()}, VK_TRUE, UINT64_MAX);

        vk::ResultValue acquireImgResult = device->acquireNextImageKHR(swapchain.get(), 1'000'000'000, swapchainImgSemaphore.get());
        if (acquireImgResult.result == vk::Result::eSuboptimalKHR || acquireImgResult.result == vk::Result::eErrorOutOfDateKHR) {
            std::cerr << "スワップチェーンを再作成します。" << std::endl;
            recreateSwapchain();
            continue;
        }
        if (acquireImgResult.result != vk::Result::eSuccess) {
            std::cerr << "次フレームの取得に失敗しました。" << std::endl;
            return -1;
        }
        device->resetFences({imgRenderedFence.get()});

        uint32_t imgIndex = acquireImgResult.value;

        cmdBufs[0]->reset();

        vk::CommandBufferBeginInfo cmdBeginInfo;
        cmdBufs[0]->begin(cmdBeginInfo);

        vk::ClearValue clearVal[1];
        clearVal[0].color.float32[0] = 0.0f;
        clearVal[0].color.float32[1] = 0.0f;
        clearVal[0].color.float32[2] = 0.0f;
        clearVal[0].color.float32[3] = 1.0f;

        vk::RenderPassBeginInfo renderpassBeginInfo;
        renderpassBeginInfo.renderPass = renderpass.get();
        renderpassBeginInfo.framebuffer = swapchainFramebufs[imgIndex].get();
        renderpassBeginInfo.renderArea = vk::Rect2D({0, 0}, {screenWidth, screenHeight});
        renderpassBeginInfo.clearValueCount = 1;
        renderpassBeginInfo.pClearValues = clearVal;

        cmdBufs[0]->beginRenderPass(renderpassBeginInfo, vk::SubpassContents::eInline);

        cmdBufs[0]->bindPipeline(vk::PipelineBindPoint::eGraphics, pipeline.get());
        cmdBufs[0]->bindVertexBuffers(0, {vertexBuf.get()}, {0});
        cmdBufs[0]->bindIndexBuffer(indexBuf.get(), 0, vk::IndexType::eUint16);
        cmdBufs[0]->bindDescriptorSets(vk::PipelineBindPoint::eGraphics, pipelineLayout.get(), 0, { descSets[0].get() }, {});
        cmdBufs[0]->drawIndexed(indices.size(), 1, 0, 0, 0);

        cmdBufs[0]->endRenderPass();

        cmdBufs[0]->end();

        vk::CommandBuffer submitCmdBuf[1] = {cmdBufs[0].get()};
        vk::SubmitInfo submitInfo;
        submitInfo.commandBufferCount = 1;
        submitInfo.pCommandBuffers = submitCmdBuf;

        vk::Semaphore renderwaitSemaphores[] = {swapchainImgSemaphore.get()};
        vk::PipelineStageFlags renderwaitStages[] = {vk::PipelineStageFlagBits::eColorAttachmentOutput};
        submitInfo.waitSemaphoreCount = 1;
        submitInfo.pWaitSemaphores = renderwaitSemaphores;
        submitInfo.pWaitDstStageMask = renderwaitStages;

        vk::Semaphore renderSignalSemaphores[] = {imgRenderedSemaphore.get()};
        submitInfo.signalSemaphoreCount = 1;
        submitInfo.pSignalSemaphores = renderSignalSemaphores;

        graphicsQueue.submit({submitInfo}, imgRenderedFence.get());

        vk::PresentInfoKHR presentInfo;

        auto presentSwapchains = {swapchain.get()};
        auto imgIndices = {imgIndex};

        presentInfo.swapchainCount = presentSwapchains.size();
        presentInfo.pSwapchains = presentSwapchains.begin();
        presentInfo.pImageIndices = imgIndices.begin();

        vk::Semaphore presenWaitSemaphores[] = {imgRenderedSemaphore.get()};
        presentInfo.waitSemaphoreCount = 1;
        presentInfo.pWaitSemaphores = presenWaitSemaphores;

        graphicsQueue.presentKHR(presentInfo);
    }

    graphicsQueue.waitIdle();
    glfwTerminate();
    return 0;
}

#version 450
#extension GL_ARB_separate_shader_objects : enable

layout(set = 0, binding = 0) uniform SceneData {
    vec2 rectCenter;
} sceneData;

layout(location = 0) in vec2 inPos;
layout(location = 1) in vec3 inColor;
layout(location = 0) out vec3 fragmentColor;

void main() {
    gl_Position = vec4(sceneData.rectCenter + inPos, 0.0, 1.0);
    fragmentColor = inColor;
}

#version 450
#extension GL_ARB_separate_shader_objects : enable

layout(location = 0) in vec3 fragmentColor;
layout(location = 0) out vec4 outColor;

void main() {
    outColor = vec4(fragmentColor, 1.0);
}

cmake_minimum_required(VERSION 3.22)

project(vulkan-test)

set(CMAKE_CXX_STANDARD 17)

add_executable(app main.cpp)

find_package(Vulkan REQUIRED)
target_include_directories(app PRIVATE ${Vulkan_INCLUDE_DIRS})
target_link_libraries(app PRIVATE ${Vulkan_LIBRARIES})

find_package(glfw3 CONFIG REQUIRED)
target_link_libraries(app PRIVATE glfw)

公開:

最終更新: