SimShip-Vulkan/vulkan_device.hpp at main · eHalbert/SimShip-Vulkan · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
// Inspired from Matej Sakmary, https://github.com/MatejSakmary, Licensed under Apache License Version 2.0

#pragma once

// 1. PROJECT
#include "vulkan_device.hpp"

// 2. LIB
#include <vulkan/vulkan.h>
#include <GLFW/glfw3.h>

// 3. WIN
#include <optional>
#include <vector>
#include <set>
#include <stdexcept>
#include <iostream>
using namespace std;


struct QueueFamilyIndices
{
    optional<uint32_t> graphicsFamily;
    optional<uint32_t> presentFamily;
    optional<uint32_t> computeFamily;

    bool isComplete()
    {
        return graphicsFamily.has_value() && presentFamily.has_value() && computeFamily.has_value();
    }
};

struct SwapChainSupportDetails
{
    VkSurfaceCapabilitiesKHR    capabilities;
    vector<VkSurfaceFormatKHR>  formats;
    vector<VkPresentModeKHR>    presentModes;
};

/* Required extensions */
const vector<const char *> deviceExtensions = {
    VK_KHR_SWAPCHAIN_EXTENSION_NAME,
    VK_EXT_MESH_SHADER_EXTENSION_NAME,
    VK_KHR_SPIRV_1_4_EXTENSION_NAME,
    VK_KHR_SPIRV_1_4_EXTENSION_NAME,
    VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME,
    VK_KHR_DEPTH_STENCIL_RESOLVE_EXTENSION_NAME };

class VulkanDevice
{
public:
    VkDevice                device;
    VkPhysicalDevice        physicalDevice;
    VkSampleCountFlagBits   msaaSamples;
    VkSurfaceKHR            surface;

    QueueFamilyIndices      familyIndices;
    VkCommandPool           graphicsCommandPool;
    VkCommandPool           computeCommandPool;

    VkQueue                 graphicsQueue;
    VkQueue                 presentQueue;
    VkQueue                 computeQueue;

    uint32_t                minOffsetAlignment;
    float                   timestampPeriod;
    VkFormat                PreferredTextureFormat;

    VulkanDevice(const VkInstance &instance, GLFWwindow* hWindow);
    ~VulkanDevice();

    VkCommandBuffer createGraphicsCommandBuffer();
    VkCommandBuffer createComputeCommandBuffer();
    VkCommandBuffer BeginSingleTimeCommands();
    void EndSingleTimeCommands(VkCommandBuffer commandBuffer);

    VkFormat findSupportedFormat(const vector<VkFormat> &candidates, VkImageTiling tiling, VkFormatFeatureFlags features);
    uint32_t findMemoryType(uint32_t typeFilter, VkMemoryPropertyFlags properties);
    SwapChainSupportDetails querySwapChainSupport(const VkPhysicalDevice device, const VkSurfaceKHR surface);
    vector<VkFormat> GetAllSupportedFormats();

    PFN_vkCmdSetPolygonModeEXT getCmdSetPolygonModeEXT() const { return vkCmdSetPolygonModeEXT; }
	PFN_vkCmdSetLineWidth getCmdSetLineWidth() const { return vkCmdSetLineWidth; }

private:
    void pickPhysicalDevice(const VkInstance &instance, const VkSurfaceKHR surface);
    void createLogicalDevice(const VkSurfaceKHR surface);

    bool isDeviceSuitable(const VkPhysicalDevice device, const VkSurfaceKHR surface);
    bool checkDeviceExtensionSupport(const VkPhysicalDevice device);
    VkSampleCountFlagBits getMaxUsableSampleCount();
    QueueFamilyIndices findQueueFamilies(const VkPhysicalDevice device, const VkSurfaceKHR surface);
    void createCommandPool();

    // Fonction pour polygon mode dynamique
    PFN_vkCmdSetPolygonModeEXT vkCmdSetPolygonModeEXT = nullptr;
    PFN_vkCmdSetLineWidth vkCmdSetLineWidth = nullptr;  // Optionnel pour épaisseur

};