Shader Modules | programmable pipeline stages

Hello_triangle/main.cpp

@@ -15,6 +15,7 @@
 #include <cstring>
 #include <optional>
 #include <set>
+#include <fstream>
 
 
 const uint32_t WIDTH = 800;
@@ -85,6 +86,7 @@ const std::vector<const char*> deviceExtensions = {
             createLogicalDevice();
             createSwapChain();
             createImageViews();
+            createGraphicsPipeline();
         }
 
         void createSurface() {
@@ -231,6 +233,69 @@ const std::vector<const char*> deviceExtensions = {
             }
         }
 
+
+        void createGraphicsPipeline() {
+            auto vertShaderCode = readFile("shaders/vert.spv");
+            auto fragShaderCode = readFile("shaders/frag.spv");
+
+            VkShaderModule vertShaderModule = createShaderModule(vertShaderCode);
+            VkShaderModule fragShaderModule = createShaderModule(fragShaderCode);
+
+            VkPipelineShaderStageCreateInfo vertShaderStageInfo{};
+            vertShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
+            vertShaderStageInfo.stage = VK_SHADER_STAGE_VERTEX_BIT;
+            vertShaderStageInfo.module = vertShaderModule;
+            vertShaderStageInfo.pName = "main";
+
+            VkPipelineShaderStageCreateInfo fragShaderStageInfo{};
+            fragShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
+            fragShaderStageInfo.stage = VK_SHADER_STAGE_FRAGMENT_BIT;
+            fragShaderStageInfo.module = fragShaderModule;
+            fragShaderStageInfo.pName = "main";
+
+
+            VkPipelineShaderStageCreateInfo shaderStages[] = { vertShaderStageInfo, fragShaderStageInfo };
+
+
+
+
+
+            vkDestroyShaderModule(device, vertShaderModule, nullptr);
+            vkDestroyShaderModule(device, fragShaderModule, nullptr);
+
+        }
+
+
+        VkShaderModule 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;
+        }
+
+        static std::vector<char> readFile(const std::string& filename) {
+            std::ifstream file(filename, std::ios::ate | std::ios::binary);
+
+            if (!file.is_open()) {
+                throw std::runtime_error("failed to open file!");
+            }
+
+            size_t fileSize = (size_t)file.tellg();
+            std::vector<char> buffer(fileSize);
+
+            file.seekg(0);
+            file.read(buffer.data(), fileSize);
+
+            file.close();
+            return buffer;
+        }
+
+
         void pickPhysicalDevice() {
             uint32_t deviceCount = 0;
             vkEnumeratePhysicalDevices(instance, &deviceCount, nullptr);

Hello_triangle/shaders/compile.bat

@@ -0,0 +1,3 @@
+glslc.exe shader.vert -o vert.spv
+glslc.exe shader.frag -o frag.spv
+pause

Hello_triangle/shaders/compile.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+glslc shader.vert -o vert.spv
+glslc shader.frag -o frag.spv

Hello_triangle/shaders/shader.frag

@@ -0,0 +1,9 @@
+#version 450
+
+layout(location = 0) in vec3 fragColor;
+
+layout(location = 0) out vec4 outColor;
+
+void main(){
+    outColor = vec4(fragColor, 1.0);
+}

Hello_triangle/shaders/shader.vert

@@ -0,0 +1,22 @@
+#version 450
+
+layout(location = 0) out vec3 fragColor;
+
+vec2 positions[3] = vec2[](
+    vec2(0.0,-0.5),
+    vec2(0.5, 0.5),
+    vec2(-0.5,0.5)
+
+);
+    
+vec3 colors[3] = vec3[](
+    vec3(1.0,0.0,0.0),
+    vec3(0.0,1.0,0.0),
+    vec3(0.0,0.0,1.0)
+);
+    
+
+void main() {
+    gl_Position = vec4(positions[gl_VertexIndex], 0.0, 1.0);
+    fragColor = colors[gl_VertexIndex];
+}