前節までで一応画面に三角形を表示することには成功したかと思います。しかし、現状では処理に無駄があるのでこれを修正していきます。
この記事を読むより先に補講2. セマフォとフェンスによる同期処理を読んでおくことをお勧めします。
処理には守るべき順序というものがあります。例えば画像を加工する処理を、画像データを読み込む処理が終わる前に始めてはいけません。こうした順序を守るため、一般には前の処理が終わるまで何かしらの方法で待機します。
前節までで書いた処理内容では、完了に時間のかかる処理を呼ぶたびに、それが終わるまで律儀にアプリケーション側で待機していました。acquireNextImageの後でフェンスで待機していたところなどがそうですね。分かりやすさのためにあのようにしていました。これでも一応正しく動きます。
しかし本当は守るべき処理の順序をGPUにあらかじめ教え込んでおいて、アプリケーション側は他のことに集中した方が良いのです。逐一指導するよりも、いっぺんに仕事を頼んでおいて終わったら教えてくれた方が効率が良いことは感覚的に分かるかと思います。そして今どきのGPUはそれができるのです。
もちろん順番を教える手間は少しかかるのですが。
処理の順番を守らせるために、セマフォというオブジェクトを作成します。補講2を読んでいない方向けにざっくり説明すると、「この処理終わったよー」というサインを表すオブジェクトです。
今、毎フレームやっている処理を整理すると、
- 次フレームで描画するイメージの準備
- レンダリング
- 画面へのプレゼンテーション
ということになります。この順番は崩せません。
- レンダリングはイメージが準備できるまでできない
- プレゼンテーションはレンダリングが終わるまでできない
ということは、2つのセマフォを作る必要があります。以下の処理をループの前あたりに追加しましょう。
vk::SemaphoreCreateInfo semaphoreCreateInfo;
vk::UniqueSemaphore swapchainImgSemaphore, imgRenderedSemaphore;
swapchainImgSemaphore = device->createSemaphoreUnique(semaphoreCreateInfo);
imgRenderedSemaphore = device->createSemaphoreUnique(semaphoreCreateInfo);
これらのセマフォを使って順序関係が守られるよう設定していきます。
イメージの準備が終わった時に、swapchainImgSemaphoreを通してレンダリングが開始できることを伝えるようにします。これでイメージ準備とレンダリングの順番が守られるようになりました。前節のコードのフェンスはもう消して構いません。
vk::ResultValue acquireImgResult = device->acquireNextImageKHR(swapchain.get(), 1'000'000'000, swapchainImgSemaphore.get()); // 完了時にシグナル状態にするセマフォを指定
if (acquireImgResult.result != vk::Result::eSuccess) {
std::cerr << "次フレームの要求に失敗しました。" << std::endl;
return -1;
}
uint32_t imgIndex = acquireImgResult.value;
// (中略)
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;
graphicsQueue.submit({ submitInfo });
acquireNextImgKHRの第三引数で完了時にシグナル状態にするセマフォを指定できます。そして補講2に書いたように、vk::SubmitInfoのメンバでシグナル状態になるのを待機するセマフォを指定します。
次はレンダリングが終了した時にimgRenderedSemaphoreを通じてプレゼンテーションが始められることを伝えるようにします。これでレンダリングとプレゼンテーションの順序が守られるようになります。前節のコードのwaitIdle()はもう消して構いません。
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 });
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);
vk::SubmitInfoに完了時にシグナル状態にするセマフォを指定しています。そして待つ方ですが、vk::PresentInfoKHRのwaitSemaphoreCount,pWaitSemaphoresでシグナル状態を待機するセマフォを指定できます。
何か送った命令が実行中の状態でプログラムが終了すると良くないので、プログラムが終了する前には1回waitIdle()を挟んでおきましょう。
graphicsQueue.presentKHR(presentInfo);
}
graphicsQueue.waitIdle(); // 追加
glfwTerminate();
return 0;
}
最後にループが一周した時のことも考えておきましょう。イメージの準備は何かに依存しているでしょうか。
前フレームのレンダリングが終わるより前に次フレームの準備が始まるのは、ゲームなどだとちょっとおかしいかもしれませんね。前フレームを見たプレイヤーが入力→入力情報を処理して次フレームのレンダリングとなるはずです。
ということで、前フレームのレンダリングが終わるまでアプリケーション側(CPU側)で待機しましょう。今度はセマフォではなくフェンスを作成します。
vk::FenceCreateInfo fenceCreateInfo;
vk::UniqueFence imgRenderedFence = device->createFenceUnique(fenceCreateInfo);
レンダリング処理のところでフェンスを設定します。
graphicsQueue.submit({ submitInfo }, imgRenderedFence.get()); // レンダリング完了時にシグナル状態にするフェンスを指定
これでレンダリング処理が終わったときに、imgRenderedFenceがシグナル状態になります。
イメージ準備処理の手前の部分でシグナル状態を待機します。また、待機状態が終わったらフェンスをリセットし、非シグナル状態に戻しておきます。
// acquireNextImageの前にレンダリング終了を待機
device->waitForFences({ imgRenderedFence.get()}, VK_TRUE, UINT64_MAX);
device->resetFences({ imgRenderedFence.get() });
vk::ResultValue acquireImgResult = device->acquireNextImageKHR(swapchain.get(), UINT64_MAX, swapchainImgSemaphore.get());
ところでこのようにするとループの1回目のとき、レンダリングの終了を待つ前フレームがないのでフェンスは永遠にシグナル状態になりません。waitForFencesはタイムアウトするまでずっと待機状態になってしまいます。ということでそれを抑止するために、最初の1回だけは素通りするよう初期状態をシグナル状態にしてあげます。
vk::FenceCreateInfo fenceCreateInfo;
fenceCreateInfo.flags = vk::FenceCreateFlagBits::eSignaled;
vk::UniqueFence imgRenderedFence = device->createFenceUnique(fenceCreateInfo);
これでうまくいくはずです。
ここまでの内容を実行してみましょう。特に見た目に変化は無いかと思いますが、正常に実行されていればOKです。
この節ではセマフォとフェンスによる処理の効率化を行いました。
次節では無効になったスワップチェーンの再作成に対応します。この節のコード
#include <iostream>
#include <fstream>
#include <filesystem>
#include <vulkan/vulkan.hpp>
#include <GLFW/glfw3.h>
const uint32_t screenWidth = 640;
const uint32_t screenHeight = 480;
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::SurfaceCapabilitiesKHR surfaceCapabilities = physicalDevice.getSurfaceCapabilitiesKHR(surface.get());
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::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;
vk::UniqueSwapchainKHR swapchain = device->createSwapchainKHRUnique(swapchainCreateInfo);
std::vector<vk::Image> swapchainImages = device->getSwapchainImagesKHR(swapchain.get());
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::PipelineVertexInputStateCreateInfo vertexInputInfo;
vertexInputInfo.vertexAttributeDescriptionCount = 0;
vertexInputInfo.pVertexAttributeDescriptions = nullptr;
vertexInputInfo.vertexBindingDescriptionCount = 0;
vertexInputInfo.pVertexBindingDescriptions = nullptr;
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;
vk::PipelineLayoutCreateInfo layoutCreateInfo;
layoutCreateInfo.setLayoutCount = 0;
layoutCreateInfo.pSetLayouts = nullptr;
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;
std::vector<vk::UniqueImageView> swapchainImageViews(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);
}
std::vector<vk::UniqueFramebuffer> swapchainFramebufs(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);
}
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);
device->resetFences({ imgRenderedFence.get() });
vk::ResultValue acquireImgResult = device->acquireNextImageKHR(swapchain.get(), 1'000'000'000, swapchainImgSemaphore.get());
if (acquireImgResult.result != vk::Result::eSuccess) {
std::cerr << "次フレームの要求に失敗しました。" << std::endl;
return -1;
}
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]->draw(3, 1, 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
void main() {
if(gl_VertexIndex == 0) {
gl_Position = vec4(0.0, -0.5, 0.0, 1.0);
} else if(gl_VertexIndex == 1) {
gl_Position = vec4(0.5, 0.5, 0.0, 1.0);
} else if(gl_VertexIndex == 2) {
gl_Position = vec4(-0.5, 0.5, 0.0, 1.0);
}
}
#version 450
#extension GL_ARB_separate_shader_objects : enable
layout(location = 0) out vec4 outColor;
void main() {
outColor = vec4(1.0, 0.0, 0.0, 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})
公開:
最終更新: