vulkan tutorial

最新推荐文章于 2024-10-29 21:00:44 发布
最新推荐文章于 2024-10-29 21:00:44 发布
阅读量286 收藏
点赞数
分类专栏： graphics
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Damon_X/article/details/118854669
版权 
#define GLFW_INCLUDE_VULKAN
#include <GLFW/glfw3.h>
#include <iostream>
#include <stdexcept>
#include <cstdlib>
#include <vector>
#include <cstring>
#include <optional>
#include <set>

const uint32_t WIDTH = 800;
const uint32_t HEIGHT = 600;
const std::vector<const char*> validationLayers = {
        "VK_LAYER_KHRONOS_validation"
};

const std::vector<const char*> deviceExtensions = {
        VK_KHR_SWAPCHAIN_EXTENSION_NAME
};

#ifdef NDEBUG
const bool enableValidationLayers = false;
#else
const bool enableValidationLayers = true;
#endif

class HelloTriangleApplication {
public:
        void run() {
                initWindow();
                initVulkan();
                mainLoop();
                cleanup();
        }
private:
        bool checkValidationLayerSupport() {
                uint32_t layerCount;
                vkEnumerateInstanceLayerProperties(&layerCount, nullptr);
                std::vector<VkLayerProperties> availableLayers(layerCount);
                vkEnumerateInstanceLayerProperties(&layerCount, availableLayers.data());
                for (const char* layerName : validationLayers) {
                        bool layerFound = false;
                        for (const auto& layerProperties : availableLayers) {
                                if (strcmp(layerName, layerProperties.layerName) == 0) {
                                        layerFound = true;
                                        break;
                                }
                        }
                        if (!layerFound) {
                                return false;
                        }
                }
                return true;
        }
        void initWindow() {
                glfwInit();
                glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
                glfwWindowHint(GLFW_RESIZABLE, GLFW_FALSE);
                window = glfwCreateWindow(WIDTH, HEIGHT, "Vulkan", nullptr, nullptr);
        }
        void createInstance() {
                if (enableValidationLayers && !checkValidationLayerSupport()) {
                        throw std::runtime_error("validation layers requested, but not available!");
                }
                VkApplicationInfo appInfo{};
                appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
                appInfo.pApplicationName = "Hello Triangle";
                appInfo.applicationVersion = VK_MAKE_VERSION(1, 0, 0);
                appInfo.pEngineName = "No Engine";
                appInfo.engineVersion = VK_MAKE_VERSION(1, 0, 0);
                appInfo.apiVersion = VK_API_VERSION_1_0;
                VkInstanceCreateInfo createInfo{};
                createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
                createInfo.pApplicationInfo = &appInfo;
                uint32_t glfwExtensionCount = 0;
                const char** glfwExtensions;
                glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount);
                std::cout << "extensions from glfwGetRequiredInstanceExtensions:\n";
                for (int i = 0; i < glfwExtensionCount; ++i) {
                        std::cout << '\t' << glfwExtensions[i] << '\n';
                }
                createInfo.enabledExtensionCount = glfwExtensionCount;
                createInfo.ppEnabledExtensionNames = glfwExtensions;
                if (enableValidationLayers) {
                        createInfo.enabledLayerCount = static_cast<uint32_t>(validationLayers.size());
                        createInfo.ppEnabledLayerNames = validationLayers.data();
                } else {
                        createInfo.enabledLayerCount = 0;
                }

                VkResult result = vkCreateInstance(&createInfo, nullptr, &instance);
                if (vkCreateInstance(&createInfo, nullptr, &instance) != VK_SUCCESS)
                        {
                                throw std::runtime_error("failed to create instance!");
                }


                uint32_t extensionCount = 0;
                vkEnumerateInstanceExtensionProperties(nullptr, &extensionCount, nullptr);
                std::vector<VkExtensionProperties> extensions(extensionCount);
                vkEnumerateInstanceExtensionProperties(nullptr, &extensionCount, extensions.data());
                int count = 0;
                std::cout << "available extensions:\n";
                for (const auto& extension : extensions) {
                        std::cout << '\t' << extension.extensionName << '\n';
                        for (int i = 0; i < glfwExtensionCount; ++i) {
                                if(!strcmp(glfwExtensions[i], extension.extensionName))
                                {
                                        std::cout << '\t' << glfwExtensions[i] << "************ is supported! "<< '\n';
                                        count++;
                                }
                        }
                }
                if(count != glfwExtensionCount)
                        std::cout << '\t' << "some extension(s) is/are not supported "<< '\n';
        }
        void initVulkan() {
                createInstance();
                createSurface();
                pickPhysicalDevice();
                createLogicalDevice();

        }
        void createSurface() {
                if (glfwCreateWindowSurface(instance, window, nullptr, &surface) != VK_SUCCESS) {
                        throw std::runtime_error("failed to create window surface!");
                }
        }
        void createLogicalDevice() {
                QueueFamilyIndices indices = findQueueFamilies(physicalDevice);
                std::vector<VkDeviceQueueCreateInfo> queueCreateInfos;
                std::set<uint32_t> uniqueQueueFamilies = {indices.graphicsFamily.value(), indices.presentFamily.value()};
                float queuePriority = 1.0f;
                for (uint32_t queueFamily : uniqueQueueFamilies) {
                        VkDeviceQueueCreateInfo queueCreateInfo{};
                        queueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
                        queueCreateInfo.queueFamilyIndex = queueFamily;
                        queueCreateInfo.queueCount = 1;
                        queueCreateInfo.pQueuePriorities = &queuePriority;
                        queueCreateInfos.push_back(queueCreateInfo);
                }

                /*VkDeviceQueueCreateInfo queueCreateInfo{};
                queueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
                queueCreateInfo.queueFamilyIndex = indices.graphicsFamily.value();
                queueCreateInfo.queueCount = 1;
                float queuePriority = 1.0f;
                queueCreateInfo.pQueuePriorities = &queuePriority;*/

                VkDeviceCreateInfo createInfo{};
                createInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
                VkPhysicalDeviceFeatures deviceFeatures{};
                //createInfo.queueCreateInfoCount = 1;
                //createInfo.pQueueCreateInfos = &queueCreateInfo;
                createInfo.queueCreateInfoCount = static_cast<uint32_t>(queueCreateInfos.size());
                createInfo.pQueueCreateInfos = queueCreateInfos.data();
                createInfo.pEnabledFeatures = &deviceFeatures;
                //createInfo.enabledExtensionCount = 0;
                createInfo.enabledExtensionCount = static_cast<uint32_t>(deviceExtensions.size());
                createInfo.ppEnabledExtensionNames = deviceExtensions.data();
                if (enableValidationLayers) {
                        createInfo.enabledLayerCount = static_cast<uint32_t>(validationLayers.size());
                        createInfo.ppEnabledLayerNames = validationLayers.data();
                } else {
                        createInfo.enabledLayerCount = 0;
                }
                if (vkCreateDevice(physicalDevice, &createInfo, nullptr, &device) != VK_SUCCESS) {
                        throw std::runtime_error("failed to create logical device!");
                }
                vkGetDeviceQueue(device, indices.graphicsFamily.value(), 0, &graphicsQueue);
                vkGetDeviceQueue(device, indices.presentFamily.value(), 0, &presentQueue);
        }
        void pickPhysicalDevice() {
                uint32_t deviceCount = 0;
                vkEnumeratePhysicalDevices(instance, &deviceCount, nullptr);
                if (deviceCount == 0) {
                        throw std::runtime_error("failed to find GPUs with Vulkan support!");
                }
                std::vector<VkPhysicalDevice> devices(deviceCount);
                vkEnumeratePhysicalDevices(instance, &deviceCount, devices.data());
                for (const auto& device : devices) {
                                if (isDeviceSuitable(device)) {
                                physicalDevice = device;
                                break;
                        }
                }
                if (physicalDevice == VK_NULL_HANDLE) {
                        throw std::runtime_error("failed to find a suitable GPU!");
                }
        }
        bool isDeviceSuitable(VkPhysicalDevice device) {
                /*VkPhysicalDeviceProperties deviceProperties;
                VkPhysicalDeviceFeatures deviceFeatures;
                vkGetPhysicalDeviceProperties(device, &deviceProperties);
                vkGetPhysicalDeviceFeatures(device, &deviceFeatures);
                return deviceProperties.deviceType == VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU &&
                        deviceFeatures.geometryShader;*/
                QueueFamilyIndices indices = findQueueFamilies(device);
                bool extensionsSupported = checkDeviceExtensionSupport(device);
                bool swapChainAdequate = false;
                if (extensionsSupported) {
                        SwapChainSupportDetails swapChainSupport = querySwapChainSupport(device);
                        swapChainAdequate = !swapChainSupport.formats.empty() && !swapChainSupport.presentModes.empty();
                }
                return indices.isComplete() && extensionsSupported && swapChainAdequate;
        }
        bool checkDeviceExtensionSupport(VkPhysicalDevice device) {
                uint32_t extensionCount;
                vkEnumerateDeviceExtensionProperties(device, nullptr, &extensionCount, nullptr);
                std::vector<VkExtensionProperties> availableExtensions(extensionCount);
                vkEnumerateDeviceExtensionProperties(device, nullptr, &extensionCount, availableExtensions.data());
                std::set<std::string> requiredExtensions(deviceExtensions.begin(), deviceExtensions.end());
                std::cout << "+++++++++++++++++"<< std::endl;
                for (const auto& extension : deviceExtensions) std::cout << extension << std::endl;
                std::cout << "*****************"<< std::endl;
                for (const auto& extension : availableExtensions) {
                        std::cout << extension.extensionName << std::endl;
                        requiredExtensions.erase(extension.extensionName);
                }
                std::cout << "-----------------" <<std::endl;
                return requiredExtensions.empty();
        }
        struct QueueFamilyIndices {
                std::optional<uint32_t> graphicsFamily;
                std::optional<uint32_t> presentFamily;
                bool isComplete() {
                        return graphicsFamily.has_value()&&
                                presentFamily.has_value();
                }
        };
        QueueFamilyIndices findQueueFamilies(VkPhysicalDevice device) {
                QueueFamilyIndices indices;
                // Logic to find queue family indices to populate struct with
                uint32_t queueFamilyCount = 0;
                vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyCount, nullptr);
                std::vector<VkQueueFamilyProperties> queueFamilies(queueFamilyCount);
                vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyCount, queueFamilies.data());
                int i = 0;
                VkBool32 presentSupport = false;
                for (const auto& queueFamily : queueFamilies) {
                        if (queueFamily.queueFlags & VK_QUEUE_GRAPHICS_BIT) {
                                indices.graphicsFamily = i;
                        }
                        vkGetPhysicalDeviceSurfaceSupportKHR(device, i, surface, &presentSupport);
                        if (presentSupport) {
                                indices.presentFamily = i;
                        }
                        if (indices.isComplete()) {
                                break;
                        }
                        i++;
                }
                return indices;
        }
        struct SwapChainSupportDetails {
                VkSurfaceCapabilitiesKHR capabilities;
                std::vector<VkSurfaceFormatKHR> formats;
                std::vector<VkPresentModeKHR> presentModes;
        };
        SwapChainSupportDetails querySwapChainSupport(VkPhysicalDevice device) {
                SwapChainSupportDetails details;
                vkGetPhysicalDeviceSurfaceCapabilitiesKHR(device, surface, &details.capabilities);
                uint32_t formatCount;
                vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &formatCount, nullptr);
                if (formatCount != 0) {
                        details.formats.resize(formatCount);
                        vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &formatCount, details.formats.data());
                }

                uint32_t presentModeCount;
                vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &presentModeCount, nullptr);
                if (presentModeCount != 0) {
                        details.presentModes.resize(presentModeCount);
                        vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &presentModeCount, details.presentModes.data());
                }

                return details;
        }
        void mainLoop() {
                while (!glfwWindowShouldClose(window)) {
                        glfwPollEvents();
                }
        }
        void cleanup() {
                vkDestroyDevice(device, nullptr);
                vkDestroySurfaceKHR(instance, surface, nullptr);
                vkDestroyInstance(instance, nullptr);
                glfwDestroyWindow(window);
                glfwTerminate();

        }
//      VkPhysicalDeviceFeatures deviceFeatures{};
private:
        VkQueue presentQueue;
        VkSurfaceKHR surface;
        VkQueue graphicsQueue;
        VkInstance instance;
        GLFWwindow* window;
        VkPhysicalDevice physicalDevice = VK_NULL_HANDLE;
        VkDevice device;
};

int main() {
        HelloTriangleApplication app;
        try {
                app.run();
        } catch (const std::exception& e) {
                std::cerr << e.what() << std::endl;
                return EXIT_FAILURE;
        }
        return EXIT_SUCCESS;
}

Makefile:

VULKAN_SDK_PATH = /usr
CFLAGS = -std=c++17 -I$(VULKAN_SDK_PATH)/include -g
LDFLAGS = -L$(VULKAN_SDK_PATH)/lib `pkg-config --static --libs glfw3` -lvulkan
VulkanTest: main.cpp
        g++ $(CFLAGS) -o VulkanTest main.cpp $(LDFLAGS)
.PHONY: test clean
test: VulkanTest
        LD_LIBRARY_PATH=$(VULKAN_SDK_PATH)/lib
                VK_LAYER_PATH=$(VULKAN_SDK_PATH)/etc/vulkan/explicit_layer.d
                ./VulkanTest
clean:
        rm -f VulkanTest

Choosing the right settings for the swap chain. page 82

Damon_X
关注
专栏目录
Vulkan Tutorial.pdf
04-29
Vulkan Tutorial.pdf 下载自：https://www.lunarg.com/vulkan-sdk/
Vulkan Tutorial 06 逻辑设备与队列
weixin_30814319的博客
05-31 173
操作系统:Windows8.1 显卡:Nivida GTX965M 开发工具：Visual Studio 2017 Introduction 在选择要使用的物理设备之后，我们需要设置一个逻辑设备用于交互。逻辑设备创建过程与instance创建过程类似，也需要描述我们需要使用的功能。因为我们已经查询过哪些队列簇可用，在这里需要进一步为逻辑设备创建具体类型的命令队列。如果有不同的需求，也可...
Vulkan Tutorial
3D编程之旅
10-29 4516
Welcome to the Vulkan Samples Tutorial本教程分为多个部分，对应于创建一个简单的Vulkan程序所需要的基本步骤。教程的每一部分直接对应于LunarG示例完成进度中的一个示例程序，并且被设计成可以根据示例的开发进度查看并测试实际代码。Tutorial Index（教程索引） Introduction Instance Enumerate Devices Devic
关于本教程（Vulkan Tutorial）
qiuzen的博客
05-16 841
（本文是对 https://vulkan-tutorial.com/ 的中文翻译） 本教程教导大家使用Vulkan图形和计算API的基础知识。Vulkan是一个新的API，它由Khronos group（OpenGL的管理组织）开发，对现代显卡提供了比以往的API（OpenGL和Direct3D）好很多的功能抽象，它能让你更好地描述你的编程意图，以便产生更好的运行效率，并减少对显卡驱动的压力。Vulkan的设计理念跟微软的Direct3D 12和Apple的Metal比较相似，它的优势在于完全跨平台，能让
vulkan tutorial.pdf
01-06
vulkan tutorial.pdf是一个非常有用的教程，适合想要学习Vulkan图形API的开发人员使用。该教程详细介绍了Vulkan API的各个方面，包括基本概念、如何设置Vulkan开发环境、如何创建窗口与表面、如何创建逻辑设备和渲染...
vulkan tutorial中文版pdf
06-23
Vulkan Tutorial中文版pdf是一份介绍Vulkan应用程序开发的教程文档。它被广泛认为是学习如何使用Vulkan编写高性能图形应用程序的最佳参考材料之一。 该教程文档提供了丰富的图形和代码示例，涵盖了Vulkan的重要特性...
vulkan_tutorial_zhcn:https
05-26
Vulkan教程翻译版（中文简体） 这是一个针对网站的中文简体翻译。这是一个个人项目，因此不对翻译质量做出保证，也不保证时刻与英文原版保持同步。如果你想协助我一起翻译这份教程，请直接在对应的markdown文档中...
VulkanTutorial（10·Framebuffers, Cmd ）
最新发布
sengyongan的博客
10-29 720
我们必须为swapchain中的所有图像Image Views创建一个Framebuffers（vector），并在绘制时使用与检索到的图像相对应的帧缓冲区，用于在渲染通道（Render Pass）中作为附件（Attachments）进行渲染每个Framebuffers的Attachments与Render Pass的Attachments描述相对应（数量和类型），它们共同定义了渲染的目标。
使用Rust实现的 Vulkan 教程 - vulkan-tutorial-rust
gitblog_00081的博客
05-23 353
使用Rust实现的 Vulkan 教程 - vulkan-tutorial-rust 项目地址:https://gitcode.com/gh_mirrors/vu/vulkan-tutorial-rust 项目介绍 vulkan-tutorial-rust 是一个基于Rust语言的项目，实现了Vulkan教程中的所有示例。借助于 ash 模块，该项目提供了一种深入学习和实践Vulkan API的方...
VulkanTutorial1：Vulkan-教程1
02-09
VulkanTest VulkanTest-教程1
Vulkan Tutorial 1 实例和物理设备
qq_41061477的博客
05-23 930
首先包括LunarG SDK的Vulkan头，它提供了函数、结构和枚举。iostream’头文件被包括在内，用于报告和传播错误initVulkanmainLoopcleanup之后的每一节都会增加一个新的函数，该函数将从initVulkan中调用，并在cleanup中为需要在最后释放的私有类成员增加一个或多个新的Vulkan对象。Vulkan对象要么用这样的函数直接创建，要么通过这样的函数分配给另一个对象。在确保一个对象不再被用于任何地方后，你需要用对应的和销毁它。
Vulkan Tutorial 4
qq_41061477的博客
05-24 1043
我们已经将渲染传递设置为期望一个与交换链图像格式相同的单一帧缓冲，但我们还没有实际创建任何图像。在渲染过程创建期间指定的附件通过将它们包装到一个对象中来绑定。帧缓冲区对象引用代表附件的所有对象。
vulkan 教程--Development environmen
lbknxy的专栏
09-02 2192
原文链接 : vulkan-tutorial 。 本打算直接在Android上学习Vulkan，但奈何Android 上的资料实在是太少，也可能我的网被墙了没找到。目前找到了一些sample code: GitHub ，也没什么教程，所以就打算先在PC上搞一阵子，毕竟PC上有这篇教程，熟悉之后再转到Android。因为公司工作机上是Windows 7系统，所以这里重点强调Vulkan
Vulkan教程(13): Graphics pipeline Shader modules(着色器模块)
vily_lei的专栏
02-04 1465
vulkan 中的 shader 模块 使用教程
Vulkan Tutorial 1 创建vulkan实例
sl8023dxf的专栏
12-07 803
在使用vulkan做任何操作之前，首先需要创建一个vulkan的vkInstance实例。 下图为vulkan的基本架构： 上图显示，应用程序被链接到一个称为Loader的vulkan库。Loader也会加载和初始化低级图形驱动程序。同样，layer也会通过Loader被加载到应用程序。Layer一般用来验证驱动程序执行的错误。正是因为vulkan将错误验证功能交给layer，所以vulk...
Vulkan Tutorial 8 深度缓冲
qq_41061477的博客
05-31 913
深度缓冲区是一个额外的附件，它存储每个位置的深度，就像颜色附件存储每个位置的颜色一样。到目前为止，我们所处理的几何体是投射到三维的，但它仍然是完全平面的。我们将使用这第三个坐标在当前的正方形上放置一个正方形，看看几何体不按深度排序时出现的问题。与纹理图像不同，我们不一定需要一个特定的格式，因为我们不会直接从程序中访问纹理。它只需要有一个合理的精度，在现实世界的应用中，至少有24比特是常见的。格式，因为对它的支持是非常普遍的（见硬件数据库），但在可能的情况下，为我们的应用增加一些额外的灵活性也是不错的。
Vulkan Tutorial（2）
3D编程之旅
11-10 1331
Create a (Logical) Device这一节对应的代码文件为 03-init_device.cpp。下一步是创建一个 VkDevice 类型的逻辑设备对象，对应于系统中的其中一个物理设备。该逻辑设备是后面用于把图形命令指示给硬件的一个关键对象。到目前为止，我们的示例已经确定了你有多少个物理设备。示例中用于枚举设备的通用函数已确保系统中至少包含一个物理设备，否则该示例会出现判断为否的断言而
VulkanTutorial（1·简述，vs环境搭建）
sengyongan的博客
10-21 535
VulkanAPI->驱动程序软件（接收API调用传递过来的指令和数据，并进行转换）->硬件对于openglAPI驱动程序会跟踪大量对象的状态，自动管理内存和同步，以及在程序运行时检查错误，与opengl不同，VulkanAPI为了保持良好的CPU性能，将状态跟踪、同步和内存管理交给了应用程序开发人员，同时将正确性检查交给各个层进行代理，而要想使用这些层必须手动启用。这些层在正常情况下不会在应用程序里执行。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值