3-8. 描画 - やっていくVulkan入門

この節ではいよいよ描画コマンドを送って実際に描画処理をやります。

早速いわゆるドローコール(描画を行うコマンド)を送ってみたいところですが、まずはレンダーパスの開始と終了を指示するコマンドを送る必要があります。

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

vk::RenderPassBeginInfo renderpassBeginInfo;
renderpassBeginInfo.renderPass = renderpass.get();
renderpassBeginInfo.framebuffer = frameBuf.get();
renderpassBeginInfo.renderArea = vk::Rect2D({ 0,0 }, { screenWidth, screenHeight });
renderpassBeginInfo.clearValueCount = 0;
renderpassBeginInfo.pClearValues = nullptr;

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

// ここでサブパス0番の処理

cmdBufs[0]->endRenderPass();

cmdBufs[0]->end();

vk::CommandBufferBeginInfo cmdBeginInfo;

cmdBufs[0]->begin(cmdBeginInfo);

vk::RenderPassBeginInfo renderpassBeginInfo;

renderpassBeginInfo.renderPass = renderpass.get();

renderpassBeginInfo.framebuffer = frameBuf.get();

renderpassBeginInfo.renderArea = vk::Rect2D({ 0,0 }, { screenWidth, screenHeight });

renderpassBeginInfo.clearValueCount = 0;

renderpassBeginInfo.pClearValues = nullptr;

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

// ここでサブパス0番の処理

cmdBufs[0]->endRenderPass();

cmdBufs[0]->end();

描画処理である以上はレンダーパスの枠組みの中でやらなければいけないので、その為です。レンダーパスを開始した直後に何らかのコマンドを送ればサブパス0番の中の処理という扱いになってくれます。ここでは3-3. レンダーパスで解説したようにサブパス1個だけのレンダーパスを使っているため、そのままレンダーパスを終えています。なお、複数のサブパスを持つレンダーパスを用いる場合は以下のように nextSubpass というコマンドで次のサブパスへ移行します。(今回は使いませんが)

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

// サブパス0番の処理

cmdBufs[0]->nextSubpass(vk::SubpassContents::eInline);

// サブパス1番の処理

cmdBufs[0]->nextSubpass(vk::SubpassContents::eInline);

// サブパス2番の処理

cmdBufs[0]->endRenderPass();

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

// サブパス0番の処理

cmdBufs[0]->nextSubpass(vk::SubpassContents::eInline);

// サブパス1番の処理

cmdBufs[0]->nextSubpass(vk::SubpassContents::eInline);

// サブパス2番の処理

cmdBufs[0]->endRenderPass();

描画処理ですが、どのパイプラインを使って行うかを示さなければなりません。これは bindPipeline というコマンドで行えます。

cmdBufs[0]->bindPipeline(vk::PipelineBindPoint::eGraphics, pipeline.get());

1	cmdBufs[0]->bindPipeline(vk::PipelineBindPoint::eGraphics, pipeline.get());

こうしてようやく長い長い下準備の果てにようやく描画コマンドを呼ぶ準備が出来ました。これです。

cmdBufs[0]->draw(3, 1, 0, 0);

1	cmdBufs[0]->draw(3, 1, 0, 0);

全てはこれをやるための道のりでした！

第1引数は頂点の数、これが3つということは頂点シェーダは3回呼び出され三角形が1つ描かれることを意味します。

第2引数はインスタンスの数です。インスタンスというのは何かというと物体のことで、例えば複数のインスタンスを扱うと同じ格好をした物体が一度に複数まとめて描画できたりします。これは応用的な話なのでここでは何も考えず1を指定します。

第3引数・第4引数は頂点のオフセットとインスタンスのオフセットで、例えば頂点の情報が2000個分あって、前の1000頂点が物体Aのモデルデータを表し後の1000頂点が物体Bのモデルデータを表すといった場合、第3引数に1000を渡して物体Bのモデル描画に使えるとかそういう感じのやつです。ここでは単純に0を指定しています。

では、無事出来上がった三角形を描画するプログラムを実行してみましょう！

…

何も出ません。

当たり前です。全てはメモリの中の出来事…

空しい…

この節では描画コマンドを呼び出し三角形を描画しました。次回はメモリの中に出来上がった三角形の画像データをファイルに書き出します。

// 環境に合わせて
#define VK_USE_PLATFORM_WIN32_KHR

#define VULKAN_HPP_TYPESAFE_CONVERSION

#include <vulkan/vulkan.hpp>
#include <fstream>
#include <filesystem>
#include <iostream>
#include <vector>

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

int main()
{
    vk::InstanceCreateInfo createInfo;

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

    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(); i++)
        {
            if (queueProps[j].queueFlags & vk::QueueFlagBits::eGraphics)
            {
                existsGraphicsQueue = true;
                graphicsQueueFamilyIndex = j;
                break;
            }
        }

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

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

    vk::DeviceCreateInfo devCreateInfo;

    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::CommandPoolCreateInfo cmdPoolCreateInfo;
    cmdPoolCreateInfo.queueFamilyIndex = graphicsQueueFamilyIndex;
    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::ImageCreateInfo imgCreateInfo;
    imgCreateInfo.imageType = vk::ImageType::e2D;
    imgCreateInfo.extent = vk::Extent3D(screenWidth, screenHeight, 1);
    imgCreateInfo.mipLevels = 1;
    imgCreateInfo.arrayLayers = 1;
    imgCreateInfo.format = vk::Format::eR8G8B8A8Unorm;
    imgCreateInfo.tiling = vk::ImageTiling::eLinear;
    imgCreateInfo.initialLayout = vk::ImageLayout::eUndefined;
    imgCreateInfo.usage = vk::ImageUsageFlagBits::eColorAttachment;
    imgCreateInfo.sharingMode = vk::SharingMode::eExclusive;
    imgCreateInfo.samples = vk::SampleCountFlagBits::e1;

    vk::UniqueImage image = device->createImageUnique(imgCreateInfo);

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

    vk::MemoryRequirements imgMemReq = device->getImageMemoryRequirements(image.get());

    vk::MemoryAllocateInfo imgMemAllocInfo;
    imgMemAllocInfo.allocationSize = imgMemReq.size;

    bool suitableMemoryTypeFound = false;
    for (size_t i = 0; i < memProps.memoryTypeCount; i++)
    {
        if (imgMemReq.memoryTypeBits & (1 << i))
        {
            imgMemAllocInfo.memoryTypeIndex = i;
            suitableMemoryTypeFound = true;
            break;
        }
    }

    if (!suitableMemoryTypeFound)
    {
        std::cerr << "使用可能なメモリタイプがありません。" << std::endl;
        return -1;
    }

    vk::UniqueDeviceMemory imgMem = device->allocateMemoryUnique(imgMemAllocInfo);

    device->bindImageMemory(image.get(), imgMem.get(), 0);

    vk::AttachmentDescription attachments[1];
    attachments[0].format = vk::Format::eR8G8B8A8Unorm;
    attachments[0].samples = vk::SampleCountFlagBits::e1;
    attachments[0].loadOp = vk::AttachmentLoadOp::eDontCare;
    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::eGeneral;

    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 = { 0, 0 };
    scissors[0].extent = { 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("vert.spv");

    std::ifstream vertSpvFile("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("frag.spv");

    std::ifstream fragSpvFile("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);

    vk::ImageViewCreateInfo imgViewCreateInfo;
    imgViewCreateInfo.image = image.get();
    imgViewCreateInfo.viewType = vk::ImageViewType::e2D;
    imgViewCreateInfo.format = vk::Format::eR8G8B8A8Unorm;
    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;

    vk::UniqueImageView imgView = device->createImageViewUnique(imgViewCreateInfo);

    vk::ImageView frameBufAttachments[1];
    frameBufAttachments[0] = imgView.get();

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

    vk::UniqueFramebuffer frameBuf = device->createFramebufferUnique(frameBufCreateInfo);

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

    vk::RenderPassBeginInfo renderpassBeginInfo;
    renderpassBeginInfo.renderPass = renderpass.get();
    renderpassBeginInfo.framebuffer = frameBuf.get();
    renderpassBeginInfo.renderArea = vk::Rect2D({ 0,0 }, { screenWidth, screenHeight });
    renderpassBeginInfo.clearValueCount = 0;
    renderpassBeginInfo.pClearValues = nullptr;

    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;

    graphicsQueue.submit({ submitInfo }, nullptr);

    return 0;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

// 環境に合わせて

#define VK_USE_PLATFORM_WIN32_KHR

#define VULKAN_HPP_TYPESAFE_CONVERSION

#include <vulkan/vulkan.hpp>

#include <fstream>

#include <filesystem>

#include <iostream>

#include <vector>

const uint32_t screenWidth = 640;

const uint32_t screenHeight = 480;

int main()

{

vk::InstanceCreateInfo createInfo;

vk::UniqueInstance instance;

instance = vk::createInstanceUnique(createInfo);

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(); i++)

{

if (queueProps[j].queueFlags & vk::QueueFlagBits::eGraphics)

{

existsGraphicsQueue = true;

graphicsQueueFamilyIndex = j;

break;

}

if (existsGraphicsQueue)

{

physicalDevice = physicalDevices[i];

existsSuitablePhysicalDevice = true;

break;

}

if (!existsSuitablePhysicalDevice)

{

std::cerr << "使用可能な物理デバイスがありません。" << std::endl;

return -1;

}

vk::DeviceCreateInfo devCreateInfo;

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::CommandPoolCreateInfo cmdPoolCreateInfo;

cmdPoolCreateInfo.queueFamilyIndex = graphicsQueueFamilyIndex;

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::ImageCreateInfo imgCreateInfo;

imgCreateInfo.imageType = vk::ImageType::e2D;

imgCreateInfo.extent = vk::Extent3D(screenWidth, screenHeight, 1);

imgCreateInfo.mipLevels = 1;

imgCreateInfo.arrayLayers = 1;

imgCreateInfo.format = vk::Format::eR8G8B8A8Unorm;

imgCreateInfo.tiling = vk::ImageTiling::eLinear;

imgCreateInfo.initialLayout = vk::ImageLayout::eUndefined;

imgCreateInfo.usage = vk::ImageUsageFlagBits::eColorAttachment;

imgCreateInfo.sharingMode = vk::SharingMode::eExclusive;

imgCreateInfo.samples = vk::SampleCountFlagBits::e1;

vk::UniqueImage image = device->createImageUnique(imgCreateInfo);

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

vk::MemoryRequirements imgMemReq = device->getImageMemoryRequirements(image.get());

vk::MemoryAllocateInfo imgMemAllocInfo;

imgMemAllocInfo.allocationSize = imgMemReq.size;

bool suitableMemoryTypeFound = false;

for (size_t i = 0; i < memProps.memoryTypeCount; i++)

{

if (imgMemReq.memoryTypeBits & (1 << i))

{

imgMemAllocInfo.memoryTypeIndex = i;

suitableMemoryTypeFound = true;

break;

}

if (!suitableMemoryTypeFound)

{

std::cerr << "使用可能なメモリタイプがありません。" << std::endl;

return -1;

}

vk::UniqueDeviceMemory imgMem = device->allocateMemoryUnique(imgMemAllocInfo);

device->bindImageMemory(image.get(), imgMem.get(), 0);

vk::AttachmentDescription attachments[1];

attachments[0].format = vk::Format::eR8G8B8A8Unorm;

attachments[0].samples = vk::SampleCountFlagBits::e1;

attachments[0].loadOp = vk::AttachmentLoadOp::eDontCare;

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::eGeneral;

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 = { 0, 0 };

scissors[0].extent = { 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("vert.spv");

std::ifstream vertSpvFile("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("frag.spv");

std::ifstream fragSpvFile("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);

vk::ImageViewCreateInfo imgViewCreateInfo;

imgViewCreateInfo.image = image.get();

imgViewCreateInfo.viewType = vk::ImageViewType::e2D;

imgViewCreateInfo.format = vk::Format::eR8G8B8A8Unorm;

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;

vk::UniqueImageView imgView = device->createImageViewUnique(imgViewCreateInfo);

vk::ImageView frameBufAttachments[1];

frameBufAttachments[0] = imgView.get();

vk::FramebufferCreateInfo frameBufCreateInfo;

frameBufCreateInfo.width = screenWidth;

frameBufCreateInfo.height = screenHeight;

frameBufCreateInfo.layers = 1;

frameBufCreateInfo.renderPass = renderpass.get();

frameBufCreateInfo.attachmentCount = 1;

frameBufCreateInfo.pAttachments = frameBufAttachments;

vk::UniqueFramebuffer frameBuf = device->createFramebufferUnique(frameBufCreateInfo);

vk::CommandBufferBeginInfo cmdBeginInfo;

cmdBufs[0]->begin(cmdBeginInfo);

vk::RenderPassBeginInfo renderpassBeginInfo;

renderpassBeginInfo.renderPass = renderpass.get();

renderpassBeginInfo.framebuffer = frameBuf.get();

renderpassBeginInfo.renderArea = vk::Rect2D({ 0,0 }, { screenWidth, screenHeight });

renderpassBeginInfo.clearValueCount = 0;

renderpassBeginInfo.pClearValues = nullptr;

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;

graphicsQueue.submit({ submitInfo }, nullptr);

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

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);
}

#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);

}

コメントを残す コメントをキャンセル

コメントを残すコメントをキャンセル