Warwick/new-engine
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
new-engine/src/main.c

838 lines
29 KiB
C
Raw Blame History

#include "dyn_arr.h"
#include <limits.h>
#include <math.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <vulkan/vulkan_core.h>
#define GLFW_INCLUDE_VULKAN
#include <GLFW/glfw3.h>
#ifdef NDEBUG
const bool enableValidationLayers = false;
#else
const bool enableValidationLayers = true;
#endif
static VKAPI_ATTR VkBool32 VKAPI_CALL
debugCallback(VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
VkDebugUtilsMessageTypeFlagsEXT messageType,
const VkDebugUtilsMessengerCallbackDataEXT *pCallbackData,
void *pUserData) {
// TODO: Put all messages into a log file
if (messageSeverity >= VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT) {
fprintf(stderr, "validation layer: %s\n", pCallbackData->pMessage);
}
return VK_FALSE;
}
const char *deviceExtensions[] = {VK_KHR_SWAPCHAIN_EXTENSION_NAME};
size_t deviceExtentionCount =
sizeof(deviceExtensions) / sizeof(deviceExtensions[0]);
const char *validationLayers[] = {"VK_LAYER_KHRONOS_validation"};
size_t validationLayerCount =
sizeof(validationLayers) / sizeof(validationLayers[0]);
typedef struct Application {
GLFWwindow *window;
VkInstance instance;
VkDebugUtilsMessengerEXT debugMessenger;
VkSurfaceKHR surface;
VkPhysicalDevice physicalDevice;
VkDevice device;
VkQueue graphicsQueue;
VkQueue presentQueue;
VkSwapchainKHR swapChain;
VkImage *swapChainImages;
uint32_t swapChainImageCount;
VkFormat swapChainImageFormat;
VkExtent2D swapChainExtent;
VkImageView *swapChainImageViews;
uint32_t swapChainImageViewCount;
VkPipelineLayout pipelineLayout;
} Application;
typedef struct SwapChainSupportDetails {
VkSurfaceCapabilitiesKHR capabilities;
uint32_t numFormats;
VkSurfaceFormatKHR *formats;
uint32_t numPresentModes;
VkPresentModeKHR *presentModes;
} SwapChainSupportDetails;
bool checkValidationLayerSupport() {
uint32_t layerCount;
vkEnumerateInstanceLayerProperties(&layerCount, NULL);
VkLayerProperties availableLayers[layerCount];
vkEnumerateInstanceLayerProperties(&layerCount, availableLayers);
for (int i = 0; i < validationLayerCount; i++) {
bool layerFound = false;
for (int j = 0; j < layerCount; j++) {
if (strcmp(availableLayers[j].layerName, validationLayers[i]) == 0) {
layerFound = true;
break;
}
}
if (!layerFound) {
return false;
}
}
return true;
}
bool verifyExtensionSupport(uint32_t extensionCount,
VkExtensionProperties *extentions,
uint32_t glfwExtensionCount,
const char **glfwExtensions) {
for (uint32_t i = 0; i < glfwExtensionCount; i++) {
bool layerFound = false;
for (uint32_t j = 0; j < extensionCount; j++) {
if (strcmp(glfwExtensions[i], extentions[j].extensionName) == 0) {
layerFound = true;
break;
}
}
if (!layerFound) {
fprintf(stderr, "Missing %s vulkan extention\n", glfwExtensions[i]);
return false;
}
}
return true;
}
void populateDebugMessengerCreateInfo(
VkDebugUtilsMessengerCreateInfoEXT *createInfo) {
createInfo->sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
createInfo->messageSeverity =
VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT |
VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT |
VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT;
createInfo->messageType = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT |
VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT |
VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT;
createInfo->pfnUserCallback = debugCallback;
}
void createInstance(Application *app) {
if (enableValidationLayers && !checkValidationLayerSupport()) {
fprintf(stderr, "Validation layers requested, but not available!\n");
exit(EXIT_FAILURE);
}
VkApplicationInfo appInfo = {
.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO,
.pApplicationName = "Hello Triangle",
.applicationVersion = VK_MAKE_VERSION(1, 0, 0),
.pEngineName = "No Engine",
.engineVersion = VK_MAKE_VERSION(1, 0, 0),
.apiVersion = VK_API_VERSION_1_0,
};
uint32_t glfwExtensionCount = 0;
const char **glfwExtensions;
glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount);
const char *glfwExtensionsDebug[glfwExtensionCount + 1];
VkInstanceCreateInfo createInfo = {
.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
.pApplicationInfo = &appInfo,
.enabledExtensionCount = glfwExtensionCount,
.ppEnabledExtensionNames = glfwExtensions,
.enabledLayerCount = 0,
};
uint32_t extensionCount = 0;
vkEnumerateInstanceExtensionProperties(NULL, &extensionCount, NULL);
VkExtensionProperties extensions[extensionCount];
vkEnumerateInstanceExtensionProperties(NULL, &extensionCount, extensions);
VkDebugUtilsMessengerCreateInfoEXT debugCreateInfo = {0};
if (enableValidationLayers) {
populateDebugMessengerCreateInfo(&debugCreateInfo);
createInfo.pNext = (VkDebugUtilsMessengerCreateInfoEXT *)&debugCreateInfo;
createInfo.enabledLayerCount = validationLayerCount;
createInfo.ppEnabledLayerNames = validationLayers;
for (size_t i = 0; i < glfwExtensionCount; i++) {
glfwExtensionsDebug[i] = glfwExtensions[i];
}
glfwExtensionsDebug[glfwExtensionCount] = VK_EXT_DEBUG_UTILS_EXTENSION_NAME;
createInfo.enabledExtensionCount = glfwExtensionCount + 1;
createInfo.ppEnabledExtensionNames = glfwExtensionsDebug;
if (!verifyExtensionSupport(extensionCount, extensions,
glfwExtensionCount + 1, glfwExtensionsDebug)) {
fprintf(
stderr,
"Failed to find all required vulkan extentions for glfw and debug\n");
exit(EXIT_FAILURE);
}
} else {
if (!verifyExtensionSupport(extensionCount, extensions, glfwExtensionCount,
glfwExtensions)) {
fprintf(stderr,
"Failed to find all required vulkan extentions for glfw\n");
exit(EXIT_FAILURE);
}
}
// This currently leaks memory on laptop :(
VkResult result = vkCreateInstance(&createInfo, NULL, &app->instance);
if (result != VK_SUCCESS) {
fprintf(stderr, "Failed to create vulkan instance\n");
exit(EXIT_FAILURE);
}
}
void initWindow(Application *app) {
glfwInit();
glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
glfwWindowHint(GLFW_RESIZABLE, GLFW_FALSE);
app->window = glfwCreateWindow(800, 600, "Vulkan", NULL, NULL);
}
VkResult CreateDebugUtilsMessengerEXT(
VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT *pCreateInfo,
const VkAllocationCallbacks *pAllocator,
VkDebugUtilsMessengerEXT *pDebugMessenger) {
PFN_vkCreateDebugUtilsMessengerEXT func =
(PFN_vkCreateDebugUtilsMessengerEXT)vkGetInstanceProcAddr(
instance, "vkCreateDebugUtilsMessengerEXT");
if (func != NULL) {
return func(instance, pCreateInfo, pAllocator, pDebugMessenger);
} else {
return VK_ERROR_EXTENSION_NOT_PRESENT;
}
}
void setupDebugMessenger(Application *app) {
if (!enableValidationLayers) {
return;
}
if (!checkValidationLayerSupport()) {
fprintf(stderr, "Validation layers requested, but not available!\n");
exit(EXIT_FAILURE);
}
VkDebugUtilsMessengerCreateInfoEXT createInfo = {};
populateDebugMessengerCreateInfo(&createInfo);
if (CreateDebugUtilsMessengerEXT(app->instance, &createInfo, NULL,
&app->debugMessenger) != VK_SUCCESS) {
fprintf(stderr, "failed to set up debug messenger!\n");
}
}
void DestroyDebugUtilsMessengerEXT(VkInstance instance,
VkDebugUtilsMessengerEXT debugMessenger,
const VkAllocationCallbacks *pAllocator) {
PFN_vkDestroyDebugUtilsMessengerEXT func =
(PFN_vkDestroyDebugUtilsMessengerEXT)vkGetInstanceProcAddr(
instance, "vkDestroyDebugUtilsMessengerEXT");
if (func != NULL) {
func(instance, debugMessenger, pAllocator);
}
}
struct QueueFamilyIndices_s {
bool graphicsFamilyExists;
uint32_t graphicsFamily;
bool presentFamilyExists;
uint32_t presentFamily;
} QueueFamilyIndices_default = {
.graphicsFamilyExists = false,
.graphicsFamily = 0,
.presentFamilyExists = false,
.presentFamily = 0,
};
typedef struct QueueFamilyIndices_s QueueFamilyIndices;
QueueFamilyIndices findQueueFamilies(VkPhysicalDevice device,
VkSurfaceKHR *surface) {
QueueFamilyIndices indices = QueueFamilyIndices_default;
uint32_t queueFamilyCount = 0;
vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyCount, NULL);
VkQueueFamilyProperties queueFamilies[queueFamilyCount];
vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyCount,
queueFamilies);
for (uint32_t i = 0; i < queueFamilyCount; i++) {
// Graphics support
if (queueFamilies[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
indices.graphicsFamily = i;
indices.graphicsFamilyExists = true;
}
// Surface support
VkBool32 presentSupport = false;
vkGetPhysicalDeviceSurfaceSupportKHR(device, i, *surface, &presentSupport);
if (presentSupport) {
indices.presentFamily = i;
indices.presentFamilyExists = true;
}
// Early break if we've found everything
if (indices.presentFamilyExists && indices.graphicsFamilyExists) {
break;
}
}
return indices;
}
bool checkDeviceExtensionSupport(VkPhysicalDevice device) {
uint32_t availableExtensionCount;
vkEnumerateDeviceExtensionProperties(device, NULL, &availableExtensionCount,
NULL);
VkExtensionProperties availableExtentions[availableExtensionCount];
vkEnumerateDeviceExtensionProperties(device, NULL, &availableExtensionCount,
availableExtentions);
for (uint i = 0; i < deviceExtentionCount; i++) {
bool extentionFound = false;
for (uint j = 0; j < availableExtensionCount; j++) {
if (strcmp(availableExtentions[j].extensionName, deviceExtensions[i]) ==
0) {
extentionFound = true;
break;
}
}
if (!extentionFound) {
return false;
}
}
return true;
}
// TODO: find a better way of managing memory
SwapChainSupportDetails querySwapchainSupport(VkPhysicalDevice device,
VkSurfaceKHR *surface) {
SwapChainSupportDetails details = {0};
vkGetPhysicalDeviceSurfaceCapabilitiesKHR(device, *surface,
&details.capabilities);
vkGetPhysicalDeviceSurfaceFormatsKHR(device, *surface, &details.numFormats,
NULL);
if (details.numFormats > 0) {
details.formats = malloc(details.numFormats * sizeof(VkSurfaceFormatKHR));
vkGetPhysicalDeviceSurfaceFormatsKHR(device, *surface, &details.numFormats,
details.formats);
}
vkGetPhysicalDeviceSurfacePresentModesKHR(device, *surface,
&details.numPresentModes, NULL);
if (details.numPresentModes > 0) {
details.presentModes =
malloc(details.numPresentModes * sizeof(VkPresentModeKHR));
vkGetPhysicalDeviceSurfacePresentModesKHR(
device, *surface, &details.numPresentModes, details.presentModes);
}
return details;
}
// Prefer one format but otherwise go for
VkSurfaceFormatKHR chooseSwapSurfaceFormat(VkSurfaceFormatKHR *availableFormats,
size_t availableFormatCount) {
for (uint i = 0; i < availableFormatCount; i++) {
if (availableFormats[i].format == VK_FORMAT_B8G8R8_SRGB &&
availableFormats[i].colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR) {
return availableFormats[i];
}
}
return availableFormats[0];
}
// Prefer mailbox otherwise go for the garenteed available present mode
VkPresentModeKHR chooseSwapPresentMode(VkPresentModeKHR *availablePresentModes,
size_t availablePresentModesCount) {
for (uint i = 0; i < availablePresentModesCount; i++) {
if (availablePresentModes[i] == VK_PRESENT_MODE_MAILBOX_KHR) {
return availablePresentModes[i];
}
}
return VK_PRESENT_MODE_FIFO_KHR;
}
VkExtent2D chooseSwapExtent(GLFWwindow *window,
const VkSurfaceCapabilitiesKHR *capabilities) {
if (capabilities->currentExtent.width != UINT_MAX) {
return capabilities->currentExtent;
}
int width, height;
glfwGetFramebufferSize(window, &width, &height);
VkExtent2D actualExtent = {(uint32_t)width, (uint32_t)height};
// check width and height are within bounds
actualExtent.width =
fmin(capabilities->maxImageExtent.width, actualExtent.width);
actualExtent.width =
fmax(capabilities->minImageExtent.width, actualExtent.width);
actualExtent.height =
fmin(capabilities->maxImageExtent.height, actualExtent.height);
actualExtent.height =
fmax(capabilities->minImageExtent.height, actualExtent.height);
return actualExtent;
}
bool isDeviceSuitable(VkPhysicalDevice device, VkSurfaceKHR *surface) {
QueueFamilyIndices indices = findQueueFamilies(device, surface);
bool completeIndeces =
indices.graphicsFamilyExists && indices.presentFamilyExists;
bool extensionsSupported = checkDeviceExtensionSupport(device);
bool swapChainAdequate = false;
if (extensionsSupported) {
SwapChainSupportDetails swapChainDetails =
querySwapchainSupport(device, surface);
if (swapChainDetails.numFormats > 0 &&
swapChainDetails.numPresentModes > 0) {
swapChainAdequate = true;
}
free(swapChainDetails.presentModes);
free(swapChainDetails.formats);
}
return completeIndeces && extensionsSupported && swapChainAdequate;
}
void pickPhysicalDevice(Application *app) {
VkPhysicalDevice physicalDevice = VK_NULL_HANDLE;
uint32_t physicalDeviceCount;
vkEnumeratePhysicalDevices(app->instance, &physicalDeviceCount, NULL);
if (physicalDeviceCount == 0) {
fprintf(stderr, "Failed to find GPU with vulkan support!\n");
fprintf(stderr, "Failed to find GPU with vulkan support!\n");
exit(EXIT_FAILURE);
}
VkPhysicalDevice physicalDevices[physicalDeviceCount];
vkEnumeratePhysicalDevices(app->instance, &physicalDeviceCount,
physicalDevices);
// TODO: pick device off of more than if it's just suitable
for (int i = 0; i < physicalDeviceCount; i++) {
if (isDeviceSuitable(physicalDevices[i], &app->surface)) {
physicalDevice = physicalDevices[i];
break;
}
}
if (physicalDevice == VK_NULL_HANDLE) {
fprintf(stderr, "Failed to find suitable GPU\n");
exit(EXIT_FAILURE);
}
app->physicalDevice = physicalDevice;
}
void createLogicalDevice(Application *app) {
QueueFamilyIndices indices =
findQueueFamilies(app->physicalDevice, &app->surface);
uint32_t queueFamilies[] = {indices.graphicsFamily, indices.presentFamily};
size_t numQueues = sizeof(queueFamilies) / sizeof(uint32_t);
// Make sure queue families don't have duplicates
// TODO: eventually move over to a set rather than a dynamic array
uint32_t *uniqueQueueFamilies = dyna_init(uint32_t);
for (uint i = 0; i < numQueues; i++) {
bool isUnique = true;
for (uint j = 0; j < dyna_length(uniqueQueueFamilies); j++) {
if (uniqueQueueFamilies[j] == queueFamilies[i]) {
isUnique = false;
break;
}
}
if (isUnique) {
dyna_append(uniqueQueueFamilies, queueFamilies[i]);
}
}
VkDeviceQueueCreateInfo queueCreateInfos[dyna_length(uniqueQueueFamilies)];
for (uint i = 0; i < dyna_length(uniqueQueueFamilies); i++) {
VkDeviceQueueCreateInfo queueCreateInfo = {};
queueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
queueCreateInfo.queueFamilyIndex = uniqueQueueFamilies[i];
queueCreateInfo.queueCount = 1;
float queuePriority = 1.0f;
queueCreateInfo.pQueuePriorities = &queuePriority;
queueCreateInfos[i] = queueCreateInfo;
}
// Specify device features
VkPhysicalDeviceFeatures deviceFeatures = {VK_FALSE};
// Specify logical device
VkDeviceCreateInfo createInfo = {};
createInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
createInfo.pQueueCreateInfos = queueCreateInfos;
createInfo.queueCreateInfoCount = dyna_length(uniqueQueueFamilies);
createInfo.pEnabledFeatures = &deviceFeatures;
createInfo.enabledExtensionCount = deviceExtentionCount;
createInfo.ppEnabledExtensionNames = deviceExtensions;
dyna_deinit(uniqueQueueFamilies);
// Old Vulkan specify layers
createInfo.enabledLayerCount = 0;
createInfo.ppEnabledLayerNames = 0;
if (enableValidationLayers) {
createInfo.enabledLayerCount = validationLayerCount;
createInfo.ppEnabledLayerNames = validationLayers;
}
if (vkCreateDevice(app->physicalDevice, &createInfo, NULL, &app->device) !=
VK_SUCCESS) {
fprintf(stderr, "Failed to create logical device.\n");
exit(EXIT_FAILURE);
}
// Set graphics queue from logical device
vkGetDeviceQueue(app->device, indices.graphicsFamily, 0, &app->graphicsQueue);
vkGetDeviceQueue(app->device, indices.presentFamily, 0, &app->presentQueue);
}
void createSurface(Application *app) {
if (glfwCreateWindowSurface(app->instance, app->window, NULL,
&app->surface) != VK_SUCCESS) {
fprintf(stderr, "Error creating vulkan surface in glfw window.");
exit(EXIT_FAILURE);
}
}
void createSwapChain(Application *app) {
SwapChainSupportDetails swapChainSupport =
querySwapchainSupport(app->physicalDevice, &app->surface);
VkSurfaceFormatKHR surfaceFormat = chooseSwapSurfaceFormat(
swapChainSupport.formats, swapChainSupport.numFormats);
VkPresentModeKHR presentMode = chooseSwapPresentMode(
swapChainSupport.presentModes, swapChainSupport.numPresentModes);
VkExtent2D extent =
chooseSwapExtent(app->window, &swapChainSupport.capabilities);
uint32_t imageCount = swapChainSupport.capabilities.minImageCount + 1;
if (swapChainSupport.capabilities.maxImageCount > 0 &&
imageCount > swapChainSupport.capabilities.maxImageCount) {
imageCount = swapChainSupport.capabilities.maxImageCount;
}
VkSwapchainCreateInfoKHR createInfo = {0};
createInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
createInfo.surface = app->surface;
createInfo.minImageCount = imageCount;
createInfo.imageFormat = surfaceFormat.format;
createInfo.imageColorSpace = surfaceFormat.colorSpace;
createInfo.imageExtent = extent;
createInfo.imageArrayLayers = 1;
createInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
QueueFamilyIndices indices =
findQueueFamilies(app->physicalDevice, &app->surface);
uint32_t queueFamilyIndices[] = {indices.graphicsFamily,
indices.presentFamily};
if (indices.graphicsFamily != indices.presentFamily) {
createInfo.imageSharingMode = VK_SHARING_MODE_CONCURRENT;
createInfo.queueFamilyIndexCount = 2;
createInfo.pQueueFamilyIndices = queueFamilyIndices;
} else {
createInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
createInfo.queueFamilyIndexCount = 0;
createInfo.pQueueFamilyIndices = NULL;
}
createInfo.preTransform = swapChainSupport.capabilities.currentTransform;
createInfo.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
createInfo.presentMode = presentMode;
createInfo.clipped = VK_TRUE;
createInfo.oldSwapchain = VK_NULL_HANDLE;
if (vkCreateSwapchainKHR(app->device, &createInfo, NULL, &app->swapChain) !=
VK_SUCCESS) {
fprintf(stderr, "Failed to create swapchain!");
exit(EXIT_FAILURE);
}
vkGetSwapchainImagesKHR(app->device, app->swapChain,
&app->swapChainImageCount, NULL);
app->swapChainImages = malloc(app->swapChainImageCount * sizeof(VkImage));
vkGetSwapchainImagesKHR(app->device, app->swapChain,
&app->swapChainImageCount, app->swapChainImages);
app->swapChainImageFormat = surfaceFormat.format;
app->swapChainExtent = extent;
free(swapChainSupport.presentModes);
free(swapChainSupport.formats);
}
void createImageViews(Application *app) {
app->swapChainImageViewCount = app->swapChainImageCount;
app->swapChainImageViews =
malloc(app->swapChainImageViewCount * sizeof(VkImageView));
for (size_t i = 0; i < app->swapChainImageViewCount; i++) {
VkImageViewCreateInfo createInfo = {0};
createInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
createInfo.image = app->swapChainImages[i];
createInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
createInfo.format = app->swapChainImageFormat;
createInfo.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;
createInfo.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;
createInfo.components.b = VK_COMPONENT_SWIZZLE_IDENTITY;
createInfo.components.a = VK_COMPONENT_SWIZZLE_IDENTITY;
createInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
createInfo.subresourceRange.baseMipLevel = 0;
createInfo.subresourceRange.levelCount = 1;
createInfo.subresourceRange.baseArrayLayer = 0;
createInfo.subresourceRange.layerCount = 1;
if (vkCreateImageView(app->device, &createInfo, NULL,
&app->swapChainImageViews[i]) != VK_SUCCESS) {
fprintf(stderr, "Failed to create image views!\n");
exit(EXIT_FAILURE);
}
}
}
// Buffer should be freed
typedef struct {
char *buffer;
size_t bufferSize;
} ShaderBuffer;
ShaderBuffer loadShaderIntoBuffer(const char *fileLocation) {
ShaderBuffer buf = {.buffer = NULL, .bufferSize = 0};
FILE *file = fopen(fileLocation, "r");
if (file == NULL) {
fprintf(stderr, "Could not open file \"%s\"!\n", fileLocation);
exit(EXIT_FAILURE);
}
if (fseek(file, 0L, SEEK_END) != 0) {
fprintf(stderr, "Could not seek to the end of file \"%s\"!\n",
fileLocation);
exit(EXIT_FAILURE);
}
buf.bufferSize = ftell(file);
if (fseek(file, 0L, SEEK_SET) != 0) {
fprintf(stderr, "Could not seek to the start of file \"%s\"!\n",
fileLocation);
exit(EXIT_FAILURE);
}
buf.buffer =
malloc(sizeof(char) * (buf.bufferSize)); // Not '\0' terminting ourselves
size_t tempSize = fread(buf.buffer, sizeof(char), buf.bufferSize, file);
if (ferror(file) != 0) {
fprintf(stderr, "Error reading file into buffer \"%s\"!\n", fileLocation);
exit(EXIT_FAILURE);
}
fclose(file);
return buf;
}
VkShaderModule createShaderModule(VkDevice device, ShaderBuffer code) {
VkShaderModuleCreateInfo createInfo = {0};
createInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
createInfo.codeSize = code.bufferSize;
createInfo.pCode = (uint32_t *)code.buffer;
VkShaderModule shaderModule;
if (vkCreateShaderModule(device, &createInfo, NULL, &shaderModule) !=
VK_SUCCESS) {
fprintf(stderr, "Failed to create shaderModule from Shader Code!");
exit(EXIT_FAILURE);
}
return shaderModule;
}
void createGraphicsPipeline(Application *app) {
ShaderBuffer vertShaderCode = loadShaderIntoBuffer("shaders/shader.vert.spv");
ShaderBuffer fragShaderCode = loadShaderIntoBuffer("shaders/shader.frag.spv");
VkShaderModule vertShaderModule =
createShaderModule(app->device, vertShaderCode);
VkShaderModule fragShaderModule =
createShaderModule(app->device, fragShaderCode);
free(vertShaderCode.buffer);
free(fragShaderCode.buffer);
VkPipelineShaderStageCreateInfo vertShaderStageInfo = {0};
vertShaderStageInfo.sType =
VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
vertShaderStageInfo.stage = VK_SHADER_STAGE_VERTEX_BIT;
vertShaderStageInfo.module = vertShaderModule;
vertShaderStageInfo.pName = "main";
vertShaderStageInfo.pSpecializationInfo = NULL;
VkPipelineShaderStageCreateInfo fragShaderStageInfo = {0};
fragShaderStageInfo.sType =
VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
fragShaderStageInfo.stage = VK_SHADER_STAGE_FRAGMENT_BIT;
fragShaderStageInfo.module = fragShaderModule;
fragShaderStageInfo.pName = "main";
vertShaderStageInfo.pSpecializationInfo = NULL;
VkPipelineShaderStageCreateInfo shaderStages[] = {vertShaderStageInfo,
fragShaderStageInfo};
size_t dynamicStatesCount = 2;
VkDynamicState dynamicStates[] = {VK_DYNAMIC_STATE_VIEWPORT,
VK_DYNAMIC_STATE_SCISSOR};
VkPipelineDynamicStateCreateInfo dynamicState = {0};
dynamicState.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
dynamicState.dynamicStateCount = dynamicStatesCount;
dynamicState.pDynamicStates = dynamicStates;
VkPipelineVertexInputStateCreateInfo vertexInputInfo = {0};
vertexInputInfo.sType =
VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
vertexInputInfo.vertexBindingDescriptionCount = 0;
vertexInputInfo.pVertexBindingDescriptions = NULL; // Optional
vertexInputInfo.vertexAttributeDescriptionCount = 0;
vertexInputInfo.pVertexAttributeDescriptions = NULL; // Optional
VkPipelineInputAssemblyStateCreateInfo inputAssembly = {0};
inputAssembly.sType =
VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
inputAssembly.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
inputAssembly.primitiveRestartEnable = VK_FALSE;
VkViewport viewport = {0};
viewport.x = 0.0f;
viewport.y = 0.0f;
viewport.width = (float)app->swapChainExtent.width;
viewport.height = (float)app->swapChainExtent.height;
viewport.minDepth = 0.0f;
viewport.maxDepth = 1.0f;
VkPipelineViewportStateCreateInfo viewportState = {0};
viewportState.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
viewportState.viewportCount = 1;
viewportState.scissorCount = 1;
VkRect2D scissor = {0};
scissor.offset.x = 0;
scissor.offset.y = 0;
scissor.extent = app->swapChainExtent;
VkPipelineRasterizationStateCreateInfo rasterizer = {0};
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;
rasterizer.depthBiasConstantFactor = 0.0f; // Optional
rasterizer.depthBiasClamp = 0.0f; // Optional
rasterizer.depthBiasSlopeFactor = 0.0f; // Optional
// disable multisampling for now
VkPipelineMultisampleStateCreateInfo multisampling = {0};
multisampling.sType =
VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
multisampling.sampleShadingEnable = VK_FALSE;
multisampling.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
multisampling.minSampleShading = 1.0f; // Optional
multisampling.pSampleMask = NULL; // Optional
multisampling.alphaToCoverageEnable = VK_FALSE; // Optional
multisampling.alphaToOneEnable = VK_FALSE; // Optional
VkPipelineColorBlendAttachmentState colorBlendAttachment = {0};
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;
colorBlendAttachment.srcColorBlendFactor = VK_BLEND_FACTOR_ONE; // Optional
colorBlendAttachment.dstColorBlendFactor = VK_BLEND_FACTOR_ZERO; // Optional
colorBlendAttachment.colorBlendOp = VK_BLEND_OP_ADD; // Optional
colorBlendAttachment.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE; // Optional
colorBlendAttachment.dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO; // Optional
colorBlendAttachment.alphaBlendOp = VK_BLEND_OP_ADD; // Optional
VkPipelineLayoutCreateInfo pipelineLayoutInfo = {0};
pipelineLayoutInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
pipelineLayoutInfo.setLayoutCount = 0; // Optional
pipelineLayoutInfo.pSetLayouts = NULL; // Optional
pipelineLayoutInfo.pushConstantRangeCount = 0; // Optional
pipelineLayoutInfo.pPushConstantRanges = NULL; // Optional
if (vkCreatePipelineLayout(app->device, &pipelineLayoutInfo, NULL,
&app->pipelineLayout) != VK_SUCCESS) {
fprintf(stderr, "Failed to create pipeline layout!");
exit(EXIT_FAILURE);
}
vkDestroyShaderModule(app->device, fragShaderModule, NULL);
vkDestroyShaderModule(app->device, vertShaderModule, NULL);
}
void initVulkan(Application *app) {
createInstance(app);
setupDebugMessenger(app);
createSurface(app);
pickPhysicalDevice(app);
createLogicalDevice(app);
createSwapChain(app);
createImageViews(app);
createGraphicsPipeline(app);
}
void mainLoop(Application *app) {
while (!glfwWindowShouldClose(app->window)) {
glfwPollEvents();
}
}
void cleanup(Application *app) {
vkDestroyPipelineLayout(app->device, app->pipelineLayout, NULL);
for (size_t i = 0; i < app->swapChainImageViewCount; i++) {
vkDestroyImageView(app->device, app->swapChainImageViews[i], NULL);
}
free(app->swapChainImageViews);
free(app->swapChainImages);
vkDestroySwapchainKHR(app->device, app->swapChain, NULL);
vkDestroyDevice(app->device, NULL);
if (enableValidationLayers) {
DestroyDebugUtilsMessengerEXT(app->instance, app->debugMessenger, NULL);
}
vkDestroySurfaceKHR(app->instance, app->surface, NULL);
vkDestroyInstance(app->instance, NULL);
glfwDestroyWindow(app->window);
glfwTerminate();
}
int main(void) {
Application app = {0};
initWindow(&app);
initVulkan(&app);
mainLoop(&app);
cleanup(&app);
return EXIT_SUCCESS;
}
Reference in a new issue View git blame Copy permalink