create graphics pipeline

Author: Piasy

README.md

@@ -1,2 +1,6 @@
 # VulkanTutorial-Android
+
 Step by step tutorial of Vulkan on Android, follow https://vulkan-tutorial.com.
+
++ We need [`vulkan_wrappe`](https://developer.android.com/ndk/guides/graphics/getting-started.html#using) on Android, which could be [download from GitHub](https://github.com/LunarG/VulkanSamples/tree/master/common).
++ In Android Studio, just put shader code under `src/main/shaders` folder, they will be compiled into `.spv` files, and packaged as assets.

app/CMakeLists.txt

@@ -23,7 +23,9 @@ add_library( # Sets the name of the library.
 
              # Provides a relative path to your source file(s).
              ${VK_WRAPPER_DIR}/vulkan_wrapper.cpp
-             ${SRC_DIR}/vulkan_triangle.cpp )
+             ${SRC_DIR}/vulkan_triangle.cpp
+             ${SRC_DIR}/vulkan_triangle_jni.cpp
+             )
 
 include_directories(${VK_WRAPPER_DIR} ${VK_VAL_LAYER_SRC_DIR}/include)
 

app/build.gradle

@@ -27,6 +27,7 @@ android {
 
     sourceSets {
         debug {
+            ndkDir = 'src/main/cpp'
             jniLibs {
                 // Must have ndk-r12 or better which including layer binaries
                 srcDirs = ["${valLayerBinDir}"]

app/src/main/cpp/vulkan_triangle.cpp

@@ -2,6 +2,12 @@
 // Created by Piasy on 26/06/2017.
 //
 
+#include <set>
+#include <algorithm>
+#include <stdexcept>
+#include <cstring>
+#include <functional>
+
 #include "vulkan_triangle.h"
 
 const int WIDTH = 800;
@@ -215,14 +221,20 @@ void HelloTriangleApplication::initVulkan() {
     createLogicalDevice();
     createSwapchain();
     createImageViews();
+    createRenderPass();
+    createGraphicsPipeline();
 }
 
 void HelloTriangleApplication::mainLoop() {
 
 }
 
 void HelloTriangleApplication::cleanUp() {
-    for (const auto& imageView : swapchainImageViews) {
+    vkDestroyPipeline(device, graphicsPipeline, nullptr);
+    vkDestroyPipelineLayout(device, pipelineLayout, nullptr);
+    vkDestroyRenderPass(device, renderPass, nullptr);
+
+    for (const auto &imageView : swapchainImageViews) {
         vkDestroyImageView(device, imageView, nullptr);
     }
 
@@ -412,8 +424,8 @@ void HelloTriangleApplication::createSwapchain() {
     swapchainImages.resize(imageCount);
     vkGetSwapchainImagesKHR(device, swapchain, &imageCount, swapchainImages.data());
 
-    swapChainImageFormat = surfaceFormat.format;
-    swapChainExtent = extent;
+    swapchainImageFormat = surfaceFormat.format;
+    swapchainExtent = extent;
 }
 
 void HelloTriangleApplication::createImageViews() {
@@ -424,7 +436,7 @@ void HelloTriangleApplication::createImageViews() {
         createInfo.image = swapchainImages[i];
 
         createInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
-        createInfo.format = swapChainImageFormat;
+        createInfo.format = swapchainImageFormat;
 
         createInfo.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;
         createInfo.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;
@@ -444,6 +456,184 @@ void HelloTriangleApplication::createImageViews() {
     }
 }
 
+void HelloTriangleApplication::createRenderPass() {
+    VkAttachmentDescription colorAttachment = {};
+    colorAttachment.format = swapchainImageFormat;
+    colorAttachment.samples = VK_SAMPLE_COUNT_1_BIT;
+    colorAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
+    colorAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
+    colorAttachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
+    colorAttachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
+    colorAttachment.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
+    colorAttachment.finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
+
+    VkAttachmentReference colorAttachmentRef = {};
+    colorAttachmentRef.attachment = 0;
+    colorAttachmentRef.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+
+    VkSubpassDescription subpass = {};
+    subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
+    subpass.colorAttachmentCount = 1;
+    subpass.pColorAttachments = &colorAttachmentRef;
+
+    VkRenderPassCreateInfo renderPassInfo = {};
+    renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
+    renderPassInfo.attachmentCount = 1;
+    renderPassInfo.pAttachments = &colorAttachment;
+    renderPassInfo.subpassCount = 1;
+    renderPassInfo.pSubpasses = &subpass;
+
+    if (vkCreateRenderPass(device, &renderPassInfo, nullptr, &renderPass) != VK_SUCCESS) {
+        throw std::runtime_error("failed to create render pass!");
+    }
+}
+
+void HelloTriangleApplication::createGraphicsPipeline() {
+    auto vertexShaderCode = readAsset(vertexShader);
+    auto fragmentShaderCode = readAsset(fragmentShader);
+
+    VkShaderModule vertexShaderModule = createShaderModule(vertexShaderCode);
+    VkShaderModule fragmentShaderModule = createShaderModule(fragmentShaderCode);
+
+    VkPipelineShaderStageCreateInfo vertexShaderStageInfo = {};
+    vertexShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
+    vertexShaderStageInfo.stage = VK_SHADER_STAGE_VERTEX_BIT;
+    vertexShaderStageInfo.module = vertexShaderModule;
+    vertexShaderStageInfo.pName = "main";
+
+    VkPipelineShaderStageCreateInfo fragmentShaderStageInfo = {};
+    fragmentShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
+    fragmentShaderStageInfo.stage = VK_SHADER_STAGE_FRAGMENT_BIT;
+    fragmentShaderStageInfo.module = fragmentShaderModule;
+    fragmentShaderStageInfo.pName = "main";
+
+    VkPipelineShaderStageCreateInfo shaderStages[] = {
+            vertexShaderStageInfo, fragmentShaderStageInfo
+    };
+
+    VkPipelineVertexInputStateCreateInfo vertexInputInfo = {};
+    vertexInputInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
+    vertexInputInfo.vertexBindingDescriptionCount = 0;
+    vertexInputInfo.vertexAttributeDescriptionCount = 0;
+
+    VkPipelineInputAssemblyStateCreateInfo inputAssembly = {};
+    inputAssembly.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
+    inputAssembly.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
+    inputAssembly.primitiveRestartEnable = VK_FALSE;
+
+    VkViewport viewport = {};
+    viewport.x = 0.0f;
+    viewport.y = 0.0f;
+    viewport.width = (float) swapchainExtent.width;
+    viewport.height = (float) swapchainExtent.height;
+    viewport.minDepth = 0.0f;
+    viewport.maxDepth = 1.0f;
+
+    VkRect2D scissor = {};
+    scissor.offset = {0, 0};
+    scissor.extent = swapchainExtent;
+
+    VkPipelineViewportStateCreateInfo viewportState = {};
+    viewportState.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
+    viewportState.viewportCount = 1;
+    viewportState.pViewports = &viewport;
+    viewportState.scissorCount = 1;
+    viewportState.pScissors = &scissor;
+
+    VkPipelineRasterizationStateCreateInfo rasterizer = {};
+    rasterizer.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
+    rasterizer.depthClampEnable = VK_FALSE;
+    rasterizer.rasterizerDiscardEnable = VK_FALSE;
+    rasterizer.polygonMode = VK_POLYGON_MODE_FILL;
+    rasterizer.lineWidth = 1.0f;
+    rasterizer.cullMode = VK_CULL_MODE_BACK_BIT;
+    rasterizer.frontFace = VK_FRONT_FACE_CLOCKWISE;
+    rasterizer.depthBiasEnable = VK_FALSE;
+
+    VkPipelineMultisampleStateCreateInfo multisampling = {};
+    multisampling.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
+    multisampling.sampleShadingEnable = VK_FALSE;
+    multisampling.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
+
+    VkPipelineColorBlendAttachmentState colorBlendAttachment = {};
+    colorBlendAttachment.colorWriteMask =
+            VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT |
+            VK_COLOR_COMPONENT_A_BIT;
+    colorBlendAttachment.blendEnable = VK_FALSE;
+
+    VkPipelineColorBlendStateCreateInfo colorBlending = {};
+    colorBlending.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
+    colorBlending.logicOpEnable = VK_FALSE;
+    colorBlending.logicOp = VK_LOGIC_OP_COPY;
+    colorBlending.attachmentCount = 1;
+    colorBlending.pAttachments = &colorBlendAttachment;
+    colorBlending.blendConstants[0] = 0.0f;
+    colorBlending.blendConstants[1] = 0.0f;
+    colorBlending.blendConstants[2] = 0.0f;
+    colorBlending.blendConstants[3] = 0.0f;
+
+    VkPipelineLayoutCreateInfo pipelineLayoutInfo = {};
+    pipelineLayoutInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
+    pipelineLayoutInfo.setLayoutCount = 0;
+    pipelineLayoutInfo.pushConstantRangeCount = 0;
+
+    if (vkCreatePipelineLayout(device, &pipelineLayoutInfo, nullptr, &pipelineLayout) !=
+        VK_SUCCESS) {
+        throw std::runtime_error("failed to create pipeline layout!");
+    }
+
+    VkGraphicsPipelineCreateInfo pipelineInfo = {};
+    pipelineInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
+    pipelineInfo.stageCount = 2;
+    pipelineInfo.pStages = shaderStages;
+    pipelineInfo.pVertexInputState = &vertexInputInfo;
+    pipelineInfo.pInputAssemblyState = &inputAssembly;
+    pipelineInfo.pViewportState = &viewportState;
+    pipelineInfo.pRasterizationState = &rasterizer;
+    pipelineInfo.pMultisampleState = &multisampling;
+    pipelineInfo.pColorBlendState = &colorBlending;
+    pipelineInfo.layout = pipelineLayout;
+    pipelineInfo.renderPass = renderPass;
+    pipelineInfo.subpass = 0;
+    pipelineInfo.basePipelineHandle = VK_NULL_HANDLE;
+
+    if (vkCreateGraphicsPipelines(device, VK_NULL_HANDLE, 1, &pipelineInfo, nullptr,
+                                  &graphicsPipeline) != VK_SUCCESS) {
+        throw std::runtime_error("failed to create graphics pipeline!");
+    }
+
+    vkDestroyShaderModule(device, vertexShaderModule, nullptr);
+    vkDestroyShaderModule(device, fragmentShaderModule, nullptr);
+}
+
+std::vector<char> HelloTriangleApplication::readAsset(const char *name) {
+    AAsset *file = AAssetManager_open(assetManager, name, AASSET_MODE_BUFFER);
+    size_t len = AAsset_getLength(file);
+    std::vector<char> buffer(len);
+
+    AAsset_read(file, buffer.data(), len);
+
+    AAsset_close(file);
+
+    LOGI("read asset %s, length %d", name, len);
+
+    return buffer;
+}
+
+VkShaderModule HelloTriangleApplication::createShaderModule(const std::vector<char> &code) {
+    VkShaderModuleCreateInfo createInfo = {};
+    createInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
+    createInfo.codeSize = code.size();
+    createInfo.pCode = reinterpret_cast<const uint32_t *>(code.data());
+
+    VkShaderModule shaderModule;
+    if (vkCreateShaderModule(device, &createInfo, nullptr, &shaderModule) != VK_SUCCESS) {
+        throw std::runtime_error("failed to create shader module!");
+    }
+
+    return shaderModule;
+}
+
 bool HelloTriangleApplication::isDeviceSuitable(VkPhysicalDevice device) {
     bool extensionsSupported = checkDeviceExtensionSupport(device);
 
@@ -531,26 +721,3 @@ SwapchainSupportDetails HelloTriangleApplication::querySwapchainSupport(VkPhysic
 
     return details;
 }
-
-extern "C" {
-JNIEXPORT void JNICALL
-Java_com_github_piasy_vulkantutorial_MainActivity_runVulkan(
-        JNIEnv *env, jobject instance, jobject surface) {
-    LOGI("Vulkan app start");
-
-    ANativeWindow *window = ANativeWindow_fromSurface(env, surface);
-    if (window == nullptr) {
-        LOGE("get window from surface fail!");
-        return;
-    }
-
-    HelloTriangleApplication app;
-    try {
-        app.run(window);
-    } catch (const std::runtime_error &e) {
-        LOGE("runtime error: %s", e.what());
-    }
-
-    LOGI("Vulkan app exit");
-}
-}

app/src/main/cpp/vulkan_triangle.h

@@ -5,17 +5,10 @@
 #ifndef VULKANTUTORIAL_ANDROID_VULKAN_TRIANGLE_H
 #define VULKANTUTORIAL_ANDROID_VULKAN_TRIANGLE_H
 
-#include <jni.h>
 #include <android/log.h>
-#include<android/native_window_jni.h>
+#include <android/asset_manager.h>
 
-#include <iostream>
 #include <vector>
-#include <set>
-#include <algorithm>
-#include <stdexcept>
-#include <cstring>
-#include <functional>
 
 #include "vulkan_wrapper/vulkan_wrapper.h"
 
@@ -40,6 +33,15 @@ struct SwapchainSupportDetails {
 
 class HelloTriangleApplication {
 public:
+    HelloTriangleApplication(
+            AAssetManager *assetManager,
+            const char *vertexShader,
+            const char *fragmentShader) :
+            assetManager(assetManager),
+            vertexShader(vertexShader),
+            fragmentShader(fragmentShader) {
+    }
+
     void run(ANativeWindow *window);
 
 private:
@@ -63,6 +65,14 @@ class HelloTriangleApplication {
 
     void createImageViews();
 
+    void createRenderPass();
+
+    void createGraphicsPipeline();
+
+    std::vector<char> readAsset(const char *name);
+
+    VkShaderModule createShaderModule(const std::vector<char> &code);
+
     bool isDeviceSuitable(VkPhysicalDevice device);
 
     bool checkDeviceExtensionSupport(VkPhysicalDevice device);
@@ -75,6 +85,10 @@ class HelloTriangleApplication {
 
     void cleanUp();
 
+    AAssetManager *assetManager;
+    const char *vertexShader;
+    const char *fragmentShader;
+
     VkInstance instance;
     VkDebugReportCallbackEXT callback;
     ANativeWindow *window;
@@ -86,8 +100,11 @@ class HelloTriangleApplication {
     VkSwapchainKHR swapchain;
     std::vector<VkImage> swapchainImages;
     std::vector<VkImageView> swapchainImageViews;
-    VkFormat swapChainImageFormat;
-    VkExtent2D swapChainExtent;
+    VkFormat swapchainImageFormat;
+    VkExtent2D swapchainExtent;
+    VkRenderPass renderPass;
+    VkPipelineLayout pipelineLayout;
+    VkPipeline graphicsPipeline;
 };
 
 #endif //VULKANTUTORIAL_ANDROID_VULKAN_TRIANGLE_H